home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / Mesa-2.2 / src / api.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-13  |  72.9 KB  |  3,580 lines
  1. /* $Id: api.c,v 1.11 1997/02/19 18:09:10 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.2
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: api.c,v $
  26.  * Revision 1.11  1997/02/19 18:09:10  brianp
  27.  * now only print "no rendering context" error if MESA_DEBUG is set
  28.  *
  29.  * Revision 1.10  1997/02/10 19:49:29  brianp
  30.  * added glResizeBuffersMESA() code
  31.  *
  32.  * Revision 1.9  1997/02/09 18:49:52  brianp
  33.  * added GL_EXT_texture3D support
  34.  *
  35.  * Revision 1.8  1997/01/08 20:55:25  brianp
  36.  * added GL_EXT_texture_object API functions
  37.  *
  38.  * Revision 1.7  1996/11/09 01:41:17  brianp
  39.  * check if there's no rendering context and return gracefully
  40.  *
  41.  * Revision 1.6  1996/11/07 04:12:13  brianp
  42.  * glTexImage[12]D() reimplemented
  43.  *
  44.  * Revision 1.5  1996/10/11 03:41:44  brianp
  45.  * added glPolygonOffsetEXT()
  46.  *
  47.  * Revision 1.4  1996/09/27 01:23:50  brianp
  48.  * added extra error checking when DEBUG is defined
  49.  *
  50.  * Revision 1.3  1996/09/26 22:52:12  brianp
  51.  * added glInterleavedArrays
  52.  *
  53.  * Revision 1.2  1996/09/14 06:27:22  brianp
  54.  * some functions didn't return needed values
  55.  *
  56.  * Revision 1.1  1996/09/13 01:38:16  brianp
  57.  * Initial revision
  58.  *
  59.  */
  60.  
  61.  
  62. #include <stdio.h>
  63. #include <stdlib.h>
  64. #include "bitmap.h"
  65. #include "context.h"
  66. #include "eval.h"
  67. #include "image.h"
  68. #include "macros.h"
  69. #include "matrix.h"
  70. #include "teximage.h"
  71. #include "types.h"
  72.  
  73.  
  74.  
  75. #ifdef MULTI_THREADING
  76.  
  77. /* Get the context associated with the calling thread */
  78. #define GET_CONTEXT    GLcontext *CC = gl_get_thread_context()
  79.  
  80. #else
  81.  
  82. /* CC is a global pointer for all threads in the address space */
  83. #define GET_CONTEXT
  84.  
  85. #endif /*MULTI_THREADED*/
  86.  
  87.  
  88.  
  89. #define CHECK_CONTEXT                            \
  90.    if (!CC) {                                \
  91.       if (getenv("MESA_DEBUG")) {                    \
  92.      fprintf(stderr,"Mesa user error: no rendering context.\n");    \
  93.       }                                    \
  94.       return;                                \
  95.    }
  96.  
  97. #define CHECK_CONTEXT_RETURN(R)                        \
  98.    if (!CC) {                                \
  99.       if (getenv("MESA_DEBUG")) {                    \
  100.          fprintf(stderr,"Mesa user error: no rendering context.\n");    \
  101.       }                                    \
  102.       return (R);                            \
  103.    }
  104.  
  105.  
  106.  
  107. #define SHORTCUT
  108.  
  109.  
  110. void glAccum( GLenum op, GLfloat value )
  111. {
  112.    GET_CONTEXT;
  113.    CHECK_CONTEXT;
  114.    (*CC->API.Accum)(CC, op, value);
  115. }
  116.  
  117.  
  118. void glAlphaFunc( GLenum func, GLclampf ref )
  119. {
  120.    GET_CONTEXT;
  121.    CHECK_CONTEXT;
  122.    (*CC->API.AlphaFunc)(CC, func, ref);
  123. }
  124.  
  125.  
  126. GLboolean glAreTexturesResident( GLsizei n, const GLuint *textures,
  127.                                  GLboolean *residences )
  128. {
  129.    GET_CONTEXT;
  130.    CHECK_CONTEXT_RETURN(GL_FALSE);
  131.    return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
  132. }
  133.  
  134.  
  135. void glArrayElement( GLint i )
  136. {
  137.    GET_CONTEXT;
  138.    CHECK_CONTEXT;
  139.    (*CC->API.ArrayElement)(CC, i);
  140. }
  141.  
  142.  
  143. void glBegin( GLenum mode )
  144. {
  145.    GET_CONTEXT;
  146.    CHECK_CONTEXT;
  147.    (*CC->API.Begin)( CC, mode );
  148. }
  149.  
  150.  
  151. void glBindTexture( GLenum target, GLuint texture )
  152. {
  153.    GET_CONTEXT;
  154.    CHECK_CONTEXT;
  155.    (*CC->API.BindTexture)(CC, target, texture);
  156. }
  157.  
  158.  
  159. void glBitmap( GLsizei width, GLsizei height,
  160.                GLfloat xorig, GLfloat yorig,
  161.                GLfloat xmove, GLfloat ymove,
  162.                const GLubyte *bitmap )
  163. {
  164.    GET_CONTEXT;
  165.    CHECK_CONTEXT;
  166.    if (!CC->CompileFlag) {
  167.       /* execute only, try optimized case where no unpacking needed */
  168.       if (   CC->Unpack.LsbFirst==GL_FALSE
  169.           && CC->Unpack.Alignment==1
  170.           && CC->Unpack.RowLength==0
  171.           && CC->Unpack.SkipPixels==0
  172.           && CC->Unpack.SkipRows==0) {
  173.          /* Special case: no unpacking needed */
  174.          struct gl_image image;
  175.          image.Width = width;
  176.          image.Height = height;
  177.          image.Components = 0;
  178.          image.Type = GL_BITMAP;
  179.          image.Data = (GLvoid *) bitmap;
  180.          (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  181.                              xmove, ymove, &image );
  182.       }
  183.       else {
  184.          struct gl_image *image;
  185.          image = gl_unpack_bitmap( CC, width, height, bitmap );
  186.          (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  187.                              xmove, ymove, image );
  188.          gl_free_image( image );
  189.       }
  190.    }
  191.    else {
  192.       /* compile and maybe execute */
  193.       struct gl_image *image;
  194.       image = gl_unpack_bitmap( CC, width, height, bitmap );
  195.       (*CC->API.Bitmap)(CC, width, height, xorig, yorig, xmove, ymove, image );
  196.    }
  197. }
  198.  
  199.  
  200. void glBlendFunc( GLenum sfactor, GLenum dfactor )
  201. {
  202.    GET_CONTEXT;
  203.    CHECK_CONTEXT;
  204.    (*CC->API.BlendFunc)(CC, sfactor, dfactor);
  205. }
  206.  
  207.  
  208. void glCallList( GLuint list )
  209. {
  210.    GET_CONTEXT;
  211.    CHECK_CONTEXT;
  212.    (*CC->API.CallList)(CC, list);
  213. }
  214.  
  215.  
  216. void glCallLists( GLsizei n, GLenum type, const GLvoid *lists )
  217. {
  218.    GET_CONTEXT;
  219.    CHECK_CONTEXT;
  220.    (*CC->API.CallLists)(CC, n, type, lists);
  221. }
  222.  
  223.  
  224. void glClear( GLbitfield mask )
  225. {
  226.    GET_CONTEXT;
  227.    CHECK_CONTEXT;
  228.    (*CC->API.Clear)(CC, mask);
  229. }
  230.  
  231.  
  232. void glClearAccum( GLfloat red, GLfloat green,
  233.               GLfloat blue, GLfloat alpha )
  234. {
  235.    GET_CONTEXT;
  236.    CHECK_CONTEXT;
  237.    (*CC->API.ClearAccum)(CC, red, green, blue, alpha);
  238. }
  239.  
  240.  
  241.  
  242. void glClearIndex( GLfloat c )
  243. {
  244.    GET_CONTEXT;
  245.    CHECK_CONTEXT;
  246.    (*CC->API.ClearIndex)(CC, c);
  247. }
  248.  
  249.  
  250. void glClearColor( GLclampf red,
  251.               GLclampf green,
  252.               GLclampf blue,
  253.               GLclampf alpha )
  254. {
  255.    GET_CONTEXT;
  256.    CHECK_CONTEXT;
  257.    (*CC->API.ClearColor)(CC, red, green, blue, alpha);
  258. }
  259.  
  260.  
  261. void glClearDepth( GLclampd depth )
  262. {
  263.    GET_CONTEXT;
  264.    CHECK_CONTEXT;
  265.    (*CC->API.ClearDepth)( CC, depth );
  266. }
  267.  
  268.  
  269. void glClearStencil( GLint s )
  270. {
  271.    GET_CONTEXT;
  272.    CHECK_CONTEXT;
  273.    (*CC->API.ClearStencil)(CC, s);
  274. }
  275.  
  276.  
  277. void glClipPlane( GLenum plane, const GLdouble *equation )
  278. {
  279.    GLfloat eq[4];
  280.    GET_CONTEXT;
  281.    CHECK_CONTEXT;
  282.    eq[0] = (GLfloat) equation[0];
  283.    eq[1] = (GLfloat) equation[1];
  284.    eq[2] = (GLfloat) equation[2];
  285.    eq[3] = (GLfloat) equation[3];
  286.    (*CC->API.ClipPlane)(CC, plane, eq );
  287. }
  288.  
  289.  
  290. void glColor3b( GLbyte red, GLbyte green, GLbyte blue )
  291. {
  292.    GET_CONTEXT;
  293.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  294.                            BYTE_TO_FLOAT(blue), 1.0F );
  295. }
  296.  
  297.  
  298. void glColor3d( GLdouble red, GLdouble green, GLdouble blue )
  299. {
  300.    GET_CONTEXT;
  301.    (*CC->API.Color4f)( CC, (GLfloat) red, (GLfloat) green,
  302.                            (GLfloat) blue, 1.0F );
  303. }
  304.  
  305.  
  306. void glColor3f( GLfloat red, GLfloat green, GLfloat blue )
  307. {
  308.    GET_CONTEXT;
  309.    (*CC->API.Color4f)( CC, red, green, blue, 1.0F );
  310. }
  311.  
  312.  
  313. void glColor3i( GLint red, GLint green, GLint blue )
  314. {
  315.    GET_CONTEXT;
  316.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  317.                            INT_TO_FLOAT(blue), 1.0F );
  318. }
  319.  
  320.  
  321. void glColor3s( GLshort red, GLshort green, GLshort blue )
  322. {
  323.    GET_CONTEXT;
  324.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  325.                            SHORT_TO_FLOAT(blue), 1.0F );
  326. }
  327.  
  328.  
  329. void glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
  330. {
  331.    GET_CONTEXT;
  332.    (*CC->API.Color4ub)( CC, red, green, blue, 255 );
  333. }
  334.  
  335.  
  336. void glColor3ui( GLuint red, GLuint green, GLuint blue )
  337. {
  338.    GET_CONTEXT;
  339.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  340.                            UINT_TO_FLOAT(blue), 1.0F );
  341. }
  342.  
  343.  
  344. void glColor3us( GLushort red, GLushort green, GLushort blue )
  345. {
  346.    GET_CONTEXT;
  347.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  348.                            USHORT_TO_FLOAT(blue), 1.0F );
  349. }
  350.  
  351.  
  352. void glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
  353. {
  354.    GET_CONTEXT;
  355.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  356.                            BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha) );
  357. }
  358.  
  359.  
  360. void glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
  361. {
  362.    GET_CONTEXT;
  363.    (*CC->API.Color4f)( CC, (GLfloat) red, (GLfloat) green,
  364.                            (GLfloat) blue, (GLfloat) alpha );
  365. }
  366.  
  367.  
  368. void glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
  369. {
  370.    GET_CONTEXT;
  371.    (*CC->API.Color4f)( CC, red, green, blue, alpha );
  372. }
  373.  
  374. void glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
  375. {
  376.    GET_CONTEXT;
  377.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  378.                            INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha) );
  379. }
  380.  
  381.  
  382. void glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
  383. {
  384.    GET_CONTEXT;
  385.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  386.                            SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha) );
  387. }
  388.  
  389. void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
  390. {
  391.    GET_CONTEXT;
  392.    (*CC->API.Color4ub)( CC, red, green, blue, alpha );
  393. }
  394.  
  395. void glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
  396. {
  397.    GET_CONTEXT;
  398.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  399.                            UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha) );
  400. }
  401.  
  402. void glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
  403. {
  404.    GET_CONTEXT;
  405.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  406.                            USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha) );
  407. }
  408.  
  409.  
  410. void glColor3bv( const GLbyte *v )
  411. {
  412.    GET_CONTEXT;
  413.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  414.                            BYTE_TO_FLOAT(v[2]), 1.0F );
  415. }
  416.  
  417.  
  418. void glColor3dv( const GLdouble *v )
  419. {
  420.    GET_CONTEXT;
  421.    (*CC->API.Color4f)( CC, (GLdouble) v[0], (GLdouble) v[1],
  422.                            (GLdouble) v[2], 1.0F );
  423. }
  424.  
  425.  
  426. void glColor3fv( const GLfloat *v )
  427. {
  428.    GET_CONTEXT;
  429.    (*CC->API.Color4f)( CC, v[0],v [1], v[2], 1.0F );
  430. }
  431.  
  432.  
  433. void glColor3iv( const GLint *v )
  434. {
  435.    GET_CONTEXT;
  436.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  437.                            INT_TO_FLOAT(v[2]), 1.0F );
  438. }
  439.  
  440.  
  441. void glColor3sv( const GLshort *v )
  442. {
  443.    GET_CONTEXT;
  444.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  445.                            SHORT_TO_FLOAT(v[2]), 1.0F );
  446. }
  447.  
  448.  
  449. void glColor3ubv( const GLubyte *v )
  450. {
  451.    GET_CONTEXT;
  452.    (*CC->API.Color4ub)( CC, v[0], v[1], v[2], 255 );
  453. }
  454.  
  455.  
  456. void glColor3uiv( const GLuint *v )
  457. {
  458.    GET_CONTEXT;
  459.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  460.                            UINT_TO_FLOAT(v[2]), 1.0F );
  461. }
  462.  
  463.  
  464. void glColor3usv( const GLushort *v )
  465. {
  466.    GET_CONTEXT;
  467.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  468.                            USHORT_TO_FLOAT(v[2]), 1.0F );
  469.  
  470. }
  471.  
  472.  
  473. void glColor4bv( const GLbyte *v )
  474. {
  475.    GET_CONTEXT;
  476.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  477.                            BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]) );
  478. }
  479.  
  480.  
  481. void glColor4dv( const GLdouble *v )
  482. {
  483.    GET_CONTEXT;
  484.    (*CC->API.Color4f)( CC, (GLdouble) v[0], (GLdouble) v[1],
  485.                            (GLdouble) v[2], (GLdouble) v[3] );
  486. }
  487.  
  488.  
  489. void glColor4fv( const GLfloat *v )
  490. {
  491.    GET_CONTEXT;
  492.    (*CC->API.Color4f)( CC, v[0], v[1], v[2], v[3] );
  493. }
  494.  
  495.  
  496. void glColor4iv( const GLint *v )
  497. {
  498.    GET_CONTEXT;
  499.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  500.                            INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
  501. }
  502.  
  503.  
  504. void glColor4sv( const GLshort *v )
  505. {
  506.    GET_CONTEXT;
  507.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  508.                            SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]) );
  509. }
  510.  
  511.  
  512. void glColor4ubv( const GLubyte *v )
  513. {
  514.    GET_CONTEXT;
  515.    (*CC->API.Color4ub)( CC, v[0], v[1], v[2], v[3] );
  516. }
  517.  
  518.  
  519. void glColor4uiv( const GLuint *v )
  520. {
  521.    GET_CONTEXT;
  522.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  523.                            UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]) );
  524. }
  525.  
  526.  
  527. void glColor4usv( const GLushort *v )
  528. {
  529.    GET_CONTEXT;
  530.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  531.                            USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]) );
  532. }
  533.  
  534.  
  535. void glColorMask( GLboolean red, GLboolean green,
  536.              GLboolean blue, GLboolean alpha )
  537. {
  538.    GET_CONTEXT;
  539.    CHECK_CONTEXT;
  540.    (*CC->API.ColorMask)(CC, red, green, blue, alpha);
  541. }
  542.  
  543.  
  544. void glColorMaterial( GLenum face, GLenum mode )
  545. {
  546.    GET_CONTEXT;
  547.    CHECK_CONTEXT;
  548.    (*CC->API.ColorMaterial)(CC, face, mode);
  549. }
  550.  
  551.  
  552. void glColorPointer( GLint size, GLenum type, GLsizei stride,
  553.                      const GLvoid *ptr )
  554. {
  555.    GET_CONTEXT;
  556.    CHECK_CONTEXT;
  557.    (*CC->API.ColorPointer)(CC, size, type, stride, ptr);
  558. }
  559.  
  560.  
  561. void glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height,
  562.               GLenum type )
  563. {
  564.    GET_CONTEXT;
  565.    CHECK_CONTEXT;
  566.    (*CC->API.CopyPixels)(CC, x, y, width, height, type);
  567. }
  568.  
  569.  
  570. void glCopyTexImage1D( GLenum target, GLint level,
  571.                        GLenum internalformat,
  572.                        GLint x, GLint y,
  573.                        GLsizei width, GLint border )
  574. {
  575.    GET_CONTEXT;
  576.    CHECK_CONTEXT;
  577.    (*CC->API.CopyTexImage1D)( CC, target, level, internalformat,
  578.                                  x, y, width, border );
  579. }
  580.  
  581.  
  582. void glCopyTexImage2D( GLenum target, GLint level,
  583.                        GLenum internalformat,
  584.                        GLint x, GLint y,
  585.                        GLsizei width, GLsizei height, GLint border )
  586. {
  587.    GET_CONTEXT;
  588.    CHECK_CONTEXT;
  589.    (*CC->API.CopyTexImage2D)( CC, target, level, internalformat,
  590.                               x, y, width, height, border );
  591. }
  592.  
  593.  
  594. void glCopyTexSubImage1D( GLenum target, GLint level,
  595.                           GLint xoffset, GLint x, GLint y,
  596.                           GLsizei width )
  597. {
  598.    GET_CONTEXT;
  599.    CHECK_CONTEXT;
  600.    (*CC->API.CopyTexSubImage1D)( CC, target, level, xoffset, x, y, width );
  601. }
  602.  
  603.  
  604. void glCopyTexSubImage2D( GLenum target, GLint level,
  605.                           GLint xoffset, GLint yoffset,
  606.                           GLint x, GLint y,
  607.                           GLsizei width, GLsizei height )
  608. {
  609.    GET_CONTEXT;
  610.    CHECK_CONTEXT;
  611.    (*CC->API.CopyTexSubImage2D)( CC, target, level, xoffset, yoffset,
  612.                                  x, y, width, height );
  613. }
  614.  
  615.  
  616.  
  617. void glCullFace( GLenum mode )
  618. {
  619.    GET_CONTEXT;
  620.    CHECK_CONTEXT;
  621.    (*CC->API.CullFace)(CC, mode);
  622. }
  623.  
  624.  
  625. void glDepthFunc( GLenum func )
  626. {
  627.    GET_CONTEXT;
  628.    CHECK_CONTEXT;
  629.    (*CC->API.DepthFunc)( CC, func );
  630. }
  631.  
  632.  
  633. void glDepthMask( GLboolean flag )
  634. {
  635.    GET_CONTEXT;
  636.    CHECK_CONTEXT;
  637.    (*CC->API.DepthMask)( CC, flag );
  638. }
  639.  
  640.  
  641. void glDepthRange( GLclampd near_val, GLclampd far_val )
  642. {
  643.    GET_CONTEXT;
  644.    CHECK_CONTEXT;
  645.    (*CC->API.DepthRange)( CC, near_val, far_val );
  646. }
  647.  
  648.  
  649. void glDeleteLists( GLuint list, GLsizei range )
  650. {
  651.    GET_CONTEXT;
  652.    CHECK_CONTEXT;
  653.    (*CC->API.DeleteLists)(CC, list, range);
  654. }
  655.  
  656.  
  657. void glDeleteTextures( GLsizei n, const GLuint *textures)
  658. {
  659.    GET_CONTEXT;
  660.    CHECK_CONTEXT;
  661.    (*CC->API.DeleteTextures)(CC, n, textures);
  662. }
  663.  
  664.  
  665. void glDisable( GLenum cap )
  666. {
  667.    GET_CONTEXT;
  668.    CHECK_CONTEXT;
  669.    (*CC->API.Disable)( CC, cap );
  670. }
  671.  
  672.  
  673. void glDisableClientState( GLenum cap )
  674. {
  675.    GET_CONTEXT;
  676.    CHECK_CONTEXT;
  677.    (*CC->API.DisableClientState)( CC, cap );
  678. }
  679.  
  680.  
  681. void glDrawArrays( GLenum mode, GLint first, GLsizei count )
  682. {
  683.    GET_CONTEXT;
  684.    CHECK_CONTEXT;
  685.    (*CC->API.DrawArrays)(CC, mode, first, count);
  686. }
  687.  
  688.  
  689. void glDrawBuffer( GLenum mode )
  690. {
  691.    GET_CONTEXT;
  692.    CHECK_CONTEXT;
  693.    (*CC->API.DrawBuffer)(CC, mode);
  694. }
  695.  
  696.  
  697. void glDrawElements( GLenum mode, GLsizei count,
  698.                      GLenum type, const GLvoid *indices )
  699. {
  700.    GET_CONTEXT;
  701.    CHECK_CONTEXT;
  702.    (*CC->API.DrawElements)( CC, mode, count, type, indices );
  703. }
  704.  
  705.  
  706. void glDrawPixels( GLsizei width, GLsizei height,
  707.                    GLenum format, GLenum type, const GLvoid *pixels )
  708. {
  709.    GET_CONTEXT;
  710.    CHECK_CONTEXT;
  711.    (*CC->API.DrawPixels)( CC, width, height, format, type, pixels );
  712. }
  713.  
  714.  
  715. void glEnable( GLenum cap )
  716. {
  717.    GET_CONTEXT;
  718.    CHECK_CONTEXT;
  719.    (*CC->API.Enable)( CC, cap );
  720. }
  721.  
  722.  
  723. void glEnableClientState( GLenum cap )
  724. {
  725.    GET_CONTEXT;
  726.    CHECK_CONTEXT;
  727.    (*CC->API.EnableClientState)( CC, cap );
  728. }
  729.  
  730.  
  731. void glEnd( void )
  732. {
  733.    GET_CONTEXT;
  734.    CHECK_CONTEXT;
  735.    (*CC->API.End)( CC );
  736. }
  737.  
  738.  
  739. void glEndList( void )
  740. {
  741.    GET_CONTEXT;
  742.    CHECK_CONTEXT;
  743.    (*CC->API.EndList)(CC);
  744. }
  745.  
  746.  
  747.  
  748.  
  749. void glEvalCoord1d( GLdouble u )
  750. {
  751.    GET_CONTEXT;
  752.    CHECK_CONTEXT;
  753.    (*CC->API.EvalCoord1f)( CC, (GLfloat) u );
  754. }
  755.  
  756.  
  757. void glEvalCoord1f( GLfloat u )
  758. {
  759.    GET_CONTEXT;
  760.    CHECK_CONTEXT;
  761.    (*CC->API.EvalCoord1f)( CC, u );
  762. }
  763.  
  764.  
  765. void glEvalCoord1dv( const GLdouble *u )
  766. {
  767.    GET_CONTEXT;
  768.    CHECK_CONTEXT;
  769.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  770. }
  771.  
  772.  
  773. void glEvalCoord1fv( const GLfloat *u )
  774. {
  775.    GET_CONTEXT;
  776.    CHECK_CONTEXT;
  777.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  778. }
  779.  
  780.  
  781. void glEvalCoord2d( GLdouble u, GLdouble v )
  782. {
  783.    GET_CONTEXT;
  784.    CHECK_CONTEXT;
  785.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u, (GLfloat) v );
  786. }
  787.  
  788.  
  789. void glEvalCoord2f( GLfloat u, GLfloat v )
  790. {
  791.    GET_CONTEXT;
  792.    CHECK_CONTEXT;
  793.    (*CC->API.EvalCoord2f)( CC, u, v );
  794. }
  795.  
  796.  
  797. void glEvalCoord2dv( const GLdouble *u )
  798. {
  799.    GET_CONTEXT;
  800.    CHECK_CONTEXT;
  801.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u[0], (GLfloat) u[1] );
  802. }
  803.  
  804.  
  805. void glEvalCoord2fv( const GLfloat *u )
  806. {
  807.    GET_CONTEXT;
  808.    CHECK_CONTEXT;
  809.    (*CC->API.EvalCoord2f)( CC, u[0], u[1] );
  810. }
  811.  
  812.  
  813. void glEvalPoint1( GLint i )
  814. {
  815.    GET_CONTEXT;
  816.    CHECK_CONTEXT;
  817.    (*CC->API.EvalPoint1)( CC, i );
  818. }
  819.  
  820.  
  821. void glEvalPoint2( GLint i, GLint j )
  822. {
  823.    GET_CONTEXT;
  824.    CHECK_CONTEXT;
  825.    (*CC->API.EvalPoint2)( CC, i, j );
  826. }
  827.  
  828.  
  829. void glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
  830. {
  831.    GET_CONTEXT;
  832.    CHECK_CONTEXT;
  833.    (*CC->API.EvalMesh1)( CC, mode, i1, i2 );
  834. }
  835.  
  836.  
  837. void glEdgeFlag( GLboolean flag )
  838. {
  839.    GET_CONTEXT;
  840.    CHECK_CONTEXT;
  841.    (*CC->API.EdgeFlag)(CC, flag);
  842. }
  843.  
  844.  
  845. void glEdgeFlagv( const GLboolean *flag )
  846. {
  847.    GET_CONTEXT;
  848.    CHECK_CONTEXT;
  849.    (*CC->API.EdgeFlag)(CC, *flag);
  850. }
  851.  
  852.  
  853. void glEdgeFlagPointer( GLsizei stride, const GLboolean *ptr )
  854. {
  855.    GET_CONTEXT;
  856.    CHECK_CONTEXT;
  857.    (*CC->API.EdgeFlagPointer)(CC, stride, ptr);
  858. }
  859.  
  860.  
  861. void glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  862. {
  863.    GET_CONTEXT;
  864.    CHECK_CONTEXT;
  865.    (*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
  866. }
  867.  
  868.  
  869. void glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
  870. {
  871.    GET_CONTEXT;
  872.    CHECK_CONTEXT;
  873.    (*CC->API.FeedbackBuffer)(CC, size, type, buffer);
  874. }
  875.  
  876.  
  877. void glFinish( void )
  878. {
  879.    GET_CONTEXT;
  880.    CHECK_CONTEXT;
  881.    (*CC->API.Finish)(CC);
  882. }
  883.  
  884.  
  885. void glFlush( void )
  886. {
  887.    GET_CONTEXT;
  888.    CHECK_CONTEXT;
  889.    (*CC->API.Flush)(CC);
  890. }
  891.  
  892.  
  893. void glFogf( GLenum pname, GLfloat param )
  894. {
  895.    GET_CONTEXT;
  896.    CHECK_CONTEXT;
  897.    (*CC->API.Fogfv)(CC, pname, ¶m);
  898. }
  899.  
  900.  
  901. void glFogi( GLenum pname, GLint param )
  902. {
  903.    GLfloat fparam = (GLfloat) param;
  904.    GET_CONTEXT;
  905.    CHECK_CONTEXT;
  906.    (*CC->API.Fogfv)(CC, pname, &fparam);
  907. }
  908.  
  909.  
  910. void glFogfv( GLenum pname, const GLfloat *params )
  911. {
  912.    GET_CONTEXT;
  913.    CHECK_CONTEXT;
  914.    (*CC->API.Fogfv)(CC, pname, params);
  915. }
  916.  
  917.  
  918. void glFogiv( GLenum pname, const GLint *params )
  919. {
  920.    GLfloat p[4];
  921.    GET_CONTEXT;
  922.    CHECK_CONTEXT;
  923.  
  924.    switch (pname) {
  925.       case GL_FOG_MODE:
  926.       case GL_FOG_DENSITY:
  927.       case GL_FOG_START:
  928.       case GL_FOG_END:
  929.       case GL_FOG_INDEX:
  930.          p[0] = (GLfloat) *params;
  931.      break;
  932.       case GL_FOG_COLOR:
  933.      p[0] = INT_TO_FLOAT( params[0] );
  934.      p[1] = INT_TO_FLOAT( params[1] );
  935.      p[2] = INT_TO_FLOAT( params[2] );
  936.      p[3] = INT_TO_FLOAT( params[3] );
  937.      break;
  938.       default:
  939.          /* Error will be caught later in gl_Fogfv */
  940.          ;
  941.    }
  942.    (*CC->API.Fogfv)( CC, pname, p );
  943. }
  944.  
  945.  
  946.  
  947. void glFrontFace( GLenum mode )
  948. {
  949.    GET_CONTEXT;
  950.    CHECK_CONTEXT;
  951.    (*CC->API.FrontFace)(CC, mode);
  952. }
  953.  
  954.  
  955. void glFrustum( GLdouble left, GLdouble right,
  956.                 GLdouble bottom, GLdouble top,
  957.                 GLdouble nearval, GLdouble farval )
  958. {
  959.    GLfloat x, y, a, b, c, d;
  960.    GLfloat m[16];
  961.    GET_CONTEXT;
  962.    CHECK_CONTEXT;
  963.  
  964.    if (nearval<=0.0 || farval<=0.0) {
  965.       gl_error( CC, GL_INVALID_VALUE, "glFrustum(near or far)" );
  966.    }
  967.  
  968.    x = (2.0*nearval) / (right-left);
  969.    y = (2.0*nearval) / (top-bottom);
  970.    a = (right+left) / (right-left);
  971.    b = (top+bottom) / (top-bottom);
  972.    c = -(farval+nearval) / ( farval-nearval);
  973.    d = -(2.0*farval*nearval) / (farval-nearval);  /* error? */
  974.  
  975. #define M(row,col)  m[col*4+row]
  976.    M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = a;      M(0,3) = 0.0F;
  977.    M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = b;      M(1,3) = 0.0F;
  978.    M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = c;      M(2,3) = d;
  979.    M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = -1.0F;  M(3,3) = 0.0F;
  980. #undef M
  981.  
  982.    (*CC->API.MultMatrixf)( CC, m );
  983. }
  984.  
  985.  
  986. GLuint glGenLists( GLsizei range )
  987. {
  988.    GET_CONTEXT;
  989.    CHECK_CONTEXT_RETURN(0);
  990.    return (*CC->API.GenLists)(CC, range);
  991. }
  992.  
  993.  
  994. void glGenTextures( GLsizei n, GLuint *textures )
  995. {
  996.    GET_CONTEXT;
  997.    CHECK_CONTEXT;
  998.    (*CC->API.GenTextures)(CC, n, textures);
  999. }
  1000.  
  1001.  
  1002. void glGetBooleanv( GLenum pname, GLboolean *params )
  1003. {
  1004.    GET_CONTEXT;
  1005.    CHECK_CONTEXT;
  1006.    (*CC->API.GetBooleanv)(CC, pname, params);
  1007. }
  1008.  
  1009.  
  1010. void glGetClipPlane( GLenum plane, GLdouble *equation )
  1011. {
  1012.    GET_CONTEXT;
  1013.    CHECK_CONTEXT;
  1014.    (*CC->API.GetClipPlane)(CC, plane, equation);
  1015. }
  1016.  
  1017.  
  1018. void glGetDoublev( GLenum pname, GLdouble *params )
  1019. {
  1020.    GET_CONTEXT;
  1021.    CHECK_CONTEXT;
  1022.    (*CC->API.GetDoublev)(CC, pname, params);
  1023. }
  1024.  
  1025.  
  1026. GLenum glGetError( void )
  1027. {
  1028.    GET_CONTEXT;
  1029.    if (!CC) {
  1030.       /* No current context */
  1031.       return GL_NO_ERROR;
  1032.    }
  1033.    return (*CC->API.GetError)(CC);
  1034. }
  1035.  
  1036.  
  1037. void glGetFloatv( GLenum pname, GLfloat *params )
  1038. {
  1039.    GET_CONTEXT;
  1040.    CHECK_CONTEXT;
  1041.    (*CC->API.GetFloatv)(CC, pname, params);
  1042. }
  1043.  
  1044.  
  1045. void glGetIntegerv( GLenum pname, GLint *params )
  1046. {
  1047.    GET_CONTEXT;
  1048.    CHECK_CONTEXT;
  1049.    (*CC->API.GetIntegerv)(CC, pname, params);
  1050. }
  1051.  
  1052.  
  1053. void glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
  1054. {
  1055.    GET_CONTEXT;
  1056.    CHECK_CONTEXT;
  1057.    (*CC->API.GetLightfv)(CC, light, pname, params);
  1058. }
  1059.  
  1060.  
  1061. void glGetLightiv( GLenum light, GLenum pname, GLint *params )
  1062. {
  1063.    GET_CONTEXT;
  1064.    CHECK_CONTEXT;
  1065.    (*CC->API.GetLightiv)(CC, light, pname, params);
  1066. }
  1067.  
  1068.  
  1069. void glGetMapdv( GLenum target, GLenum query, GLdouble *v )
  1070. {
  1071.    GET_CONTEXT;
  1072.    CHECK_CONTEXT;
  1073.    (*CC->API.GetMapdv)( CC, target, query, v );
  1074. }
  1075.  
  1076.  
  1077. void glGetMapfv( GLenum target, GLenum query, GLfloat *v )
  1078. {
  1079.    GET_CONTEXT;
  1080.    CHECK_CONTEXT;
  1081.    (*CC->API.GetMapfv)( CC, target, query, v );
  1082. }
  1083.  
  1084.  
  1085. void glGetMapiv( GLenum target, GLenum query, GLint *v )
  1086. {
  1087.    GET_CONTEXT;
  1088.    CHECK_CONTEXT;
  1089.    (*CC->API.GetMapiv)( CC, target, query, v );
  1090. }
  1091.  
  1092.  
  1093. void glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
  1094. {
  1095.    GET_CONTEXT;
  1096.    CHECK_CONTEXT;
  1097.    (*CC->API.GetMaterialfv)(CC, face, pname, params);
  1098. }
  1099.  
  1100.  
  1101. void glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
  1102. {
  1103.    GET_CONTEXT;
  1104.    CHECK_CONTEXT;
  1105.    (*CC->API.GetMaterialiv)(CC, face, pname, params);
  1106. }
  1107.  
  1108.  
  1109. void glGetPixelMapfv( GLenum map, GLfloat *values )
  1110. {
  1111.    GET_CONTEXT;
  1112.    CHECK_CONTEXT;
  1113.    (*CC->API.GetPixelMapfv)(CC, map, values);
  1114. }
  1115.  
  1116.  
  1117. void glGetPixelMapuiv( GLenum map, GLuint *values )
  1118. {
  1119.    GET_CONTEXT;
  1120.    CHECK_CONTEXT;
  1121.    (*CC->API.GetPixelMapuiv)(CC, map, values);
  1122. }
  1123.  
  1124.  
  1125. void glGetPixelMapusv( GLenum map, GLushort *values )
  1126. {
  1127.    GET_CONTEXT;
  1128.    CHECK_CONTEXT;
  1129.    (*CC->API.GetPixelMapusv)(CC, map, values);
  1130. }
  1131.  
  1132.  
  1133. void glGetPointerv( GLenum pname, GLvoid **params )
  1134. {
  1135.    GET_CONTEXT;
  1136.    CHECK_CONTEXT;
  1137.    (*CC->API.GetPointerv)(CC, pname, params);
  1138. }
  1139.  
  1140.  
  1141. void glGetPolygonStipple( GLubyte *mask )
  1142. {
  1143.    GET_CONTEXT;
  1144.    CHECK_CONTEXT;
  1145.    (*CC->API.GetPolygonStipple)(CC, mask);
  1146. }
  1147.  
  1148.  
  1149. const GLubyte *glGetString( GLenum name )
  1150. {
  1151.    GET_CONTEXT;
  1152.    CHECK_CONTEXT_RETURN(NULL);
  1153.    return (*CC->API.GetString)(CC, name);
  1154. }
  1155.  
  1156.  
  1157.  
  1158. void glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
  1159. {
  1160.    GET_CONTEXT;
  1161.    CHECK_CONTEXT;
  1162.    (*CC->API.GetTexEnvfv)(CC, target, pname, params);
  1163. }
  1164.  
  1165.  
  1166. void glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
  1167. {
  1168.    GET_CONTEXT;
  1169.    CHECK_CONTEXT;
  1170.    (*CC->API.GetTexEnviv)(CC, target, pname, params);
  1171. }
  1172.  
  1173.  
  1174. void glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
  1175. {
  1176.    GET_CONTEXT;
  1177.    CHECK_CONTEXT;
  1178.    (*CC->API.GetTexGeniv)(CC, coord, pname, params);
  1179. }
  1180.  
  1181.  
  1182. void glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
  1183. {
  1184.    GET_CONTEXT;
  1185.    CHECK_CONTEXT;
  1186.    (*CC->API.GetTexGendv)(CC, coord, pname, params);
  1187. }
  1188.  
  1189.  
  1190. void glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
  1191. {
  1192.    GET_CONTEXT;
  1193.    CHECK_CONTEXT;
  1194.    (*CC->API.GetTexGenfv)(CC, coord, pname, params);
  1195. }
  1196.  
  1197.  
  1198.  
  1199. void glGetTexImage( GLenum target, GLint level, GLenum format,
  1200.                   GLenum type, GLvoid *pixels )
  1201. {
  1202.    GET_CONTEXT;
  1203.    CHECK_CONTEXT;
  1204.    (*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
  1205. }
  1206.  
  1207.  
  1208. void glGetTexLevelParameterfv( GLenum target, GLint level,
  1209.                                GLenum pname, GLfloat *params )
  1210. {
  1211.    GET_CONTEXT;
  1212.    CHECK_CONTEXT;
  1213.    (*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
  1214. }
  1215.  
  1216.  
  1217. void glGetTexLevelParameteriv( GLenum target, GLint level,
  1218.                                GLenum pname, GLint *params )
  1219. {
  1220.    GET_CONTEXT;
  1221.    CHECK_CONTEXT;
  1222.    (*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
  1223. }
  1224.  
  1225.  
  1226.  
  1227.  
  1228. void glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params)
  1229. {
  1230.    GET_CONTEXT;
  1231.    CHECK_CONTEXT;
  1232.    (*CC->API.GetTexParameterfv)(CC, target, pname, params);
  1233. }
  1234.  
  1235.  
  1236. void glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
  1237. {
  1238.    GET_CONTEXT;
  1239.    CHECK_CONTEXT;
  1240.    (*CC->API.GetTexParameteriv)(CC, target, pname, params);
  1241. }
  1242.  
  1243.  
  1244. void glHint( GLenum target, GLenum mode )
  1245. {
  1246.    GET_CONTEXT;
  1247.    CHECK_CONTEXT;
  1248.    (*CC->API.Hint)(CC, target, mode);
  1249. }
  1250.  
  1251.  
  1252. void glIndexd( GLdouble c )
  1253. {
  1254.    GET_CONTEXT;
  1255.    (*CC->API.Indexf)( CC, (GLfloat) c );
  1256. }
  1257.  
  1258.  
  1259. void glIndexf( GLfloat c )
  1260. {
  1261.    GET_CONTEXT;
  1262.    (*CC->API.Indexf)( CC, c );
  1263. }
  1264.  
  1265.  
  1266. void glIndexi( GLint c )
  1267. {
  1268.    GET_CONTEXT;
  1269.    (*CC->API.Indexi)( CC, c );
  1270. }
  1271.  
  1272.  
  1273. void glIndexs( GLshort c )
  1274. {
  1275.    GET_CONTEXT;
  1276.    (*CC->API.Indexi)( CC, (GLint) c );
  1277. }
  1278.  
  1279.  
  1280. #ifdef GL_VERSION_1_1
  1281. void glIndexub( GLubyte c )
  1282. {
  1283.    GET_CONTEXT;
  1284.    (*CC->API.Indexi)( CC, (GLint) c );
  1285. }
  1286. #endif
  1287.  
  1288.  
  1289. void glIndexdv( const GLdouble *c )
  1290. {
  1291.    GET_CONTEXT;
  1292.    (*CC->API.Indexf)( CC, (GLfloat) *c );
  1293. }
  1294.  
  1295.  
  1296. void glIndexfv( const GLfloat *c )
  1297. {
  1298.    GET_CONTEXT;
  1299.    (*CC->API.Indexf)( CC, *c );
  1300. }
  1301.  
  1302.  
  1303. void glIndexiv( const GLint *c )
  1304. {
  1305.    GET_CONTEXT;
  1306.    (*CC->API.Indexi)( CC, *c );
  1307. }
  1308.  
  1309.  
  1310. void glIndexsv( const GLshort *c )
  1311. {
  1312.    GET_CONTEXT;
  1313.    (*CC->API.Indexi)( CC, (GLint) *c );
  1314. }
  1315.  
  1316.  
  1317. #ifdef GL_VERSION_1_1
  1318. void glIndexubv( const GLubyte *c )
  1319. {
  1320.    GET_CONTEXT;
  1321.    (*CC->API.Indexi)( CC, (GLint) *c );
  1322. }
  1323. #endif
  1324.  
  1325.  
  1326. void glIndexMask( GLuint mask )
  1327. {
  1328.    GET_CONTEXT;
  1329.    (*CC->API.IndexMask)(CC, mask);
  1330. }
  1331.  
  1332.  
  1333. void glIndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
  1334. {
  1335.    GET_CONTEXT;
  1336.    CHECK_CONTEXT;
  1337.    (*CC->API.IndexPointer)(CC, type, stride, ptr);
  1338. }
  1339.  
  1340.  
  1341. void glInterleavedArrays( GLenum format, GLsizei stride,
  1342.                           const GLvoid *pointer )
  1343. {
  1344.    GET_CONTEXT;
  1345.    CHECK_CONTEXT;
  1346.    (*CC->API.InterleavedArrays)( CC, format, stride, pointer );
  1347. }
  1348.  
  1349.  
  1350. void glInitNames( void )
  1351. {
  1352.    GET_CONTEXT;
  1353.    CHECK_CONTEXT;
  1354.    (*CC->API.InitNames)(CC);
  1355. }
  1356.  
  1357.  
  1358. GLboolean glIsList( GLuint list )
  1359. {
  1360.    GET_CONTEXT;
  1361.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1362.    return (*CC->API.IsList)(CC, list);
  1363. }
  1364.  
  1365.  
  1366. GLboolean glIsTexture( GLuint texture )
  1367. {
  1368.    GET_CONTEXT;
  1369.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1370.    return (*CC->API.IsTexture)(CC, texture);
  1371. }
  1372.  
  1373.  
  1374. void glLightf( GLenum light, GLenum pname, GLfloat param )
  1375. {
  1376.    GET_CONTEXT;
  1377.    CHECK_CONTEXT;
  1378.    (*CC->API.Lightfv)( CC, light, pname, ¶m, 1 );
  1379. }
  1380.  
  1381.  
  1382.  
  1383. void glLighti( GLenum light, GLenum pname, GLint param )
  1384. {
  1385.    GLfloat fparam = (GLfloat) param;
  1386.    GET_CONTEXT;
  1387.    CHECK_CONTEXT;
  1388.    (*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
  1389. }
  1390.  
  1391.  
  1392.  
  1393. void glLightfv( GLenum light, GLenum pname, const GLfloat *params )
  1394. {
  1395.    GET_CONTEXT;
  1396.    CHECK_CONTEXT;
  1397.    (*CC->API.Lightfv)( CC, light, pname, params, 4 );
  1398. }
  1399.  
  1400.  
  1401.  
  1402. void glLightiv( GLenum light, GLenum pname, const GLint *params )
  1403. {
  1404.    GLfloat fparam[4];
  1405.    GET_CONTEXT;
  1406.    CHECK_CONTEXT;
  1407.  
  1408.    switch (pname) {
  1409.       case GL_AMBIENT:
  1410.       case GL_DIFFUSE:
  1411.       case GL_SPECULAR:
  1412.          fparam[0] = INT_TO_FLOAT( params[0] );
  1413.          fparam[1] = INT_TO_FLOAT( params[1] );
  1414.          fparam[2] = INT_TO_FLOAT( params[2] );
  1415.          fparam[3] = INT_TO_FLOAT( params[3] );
  1416.          break;
  1417.       case GL_POSITION:
  1418.          fparam[0] = (GLfloat) params[0];
  1419.          fparam[1] = (GLfloat) params[1];
  1420.          fparam[2] = (GLfloat) params[2];
  1421.          fparam[3] = (GLfloat) params[3];
  1422.          break;
  1423.       case GL_SPOT_DIRECTION:
  1424.          fparam[0] = (GLfloat) params[0];
  1425.          fparam[1] = (GLfloat) params[1];
  1426.          fparam[2] = (GLfloat) params[2];
  1427.          break;
  1428.       case GL_SPOT_EXPONENT:
  1429.       case GL_SPOT_CUTOFF:
  1430.       case GL_CONSTANT_ATTENUATION:
  1431.       case GL_LINEAR_ATTENUATION:
  1432.       case GL_QUADRATIC_ATTENUATION:
  1433.          fparam[0] = (GLfloat) params[0];
  1434.          break;
  1435.       default:
  1436.          /* error will be caught later in gl_Lightfv */
  1437.          ;
  1438.    }
  1439.    (*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
  1440. }
  1441.  
  1442.  
  1443.  
  1444. void glLightModelf( GLenum pname, GLfloat param )
  1445. {
  1446.    GET_CONTEXT;
  1447.    CHECK_CONTEXT;
  1448.    (*CC->API.LightModelfv)( CC, pname, ¶m );
  1449. }
  1450.  
  1451.  
  1452. void glLightModeli( GLenum pname, GLint param )
  1453. {
  1454.    GLfloat fparam[4];
  1455.    GET_CONTEXT;
  1456.    CHECK_CONTEXT;
  1457.    fparam[0] = (GLfloat) param;
  1458.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1459. }
  1460.  
  1461.  
  1462. void glLightModelfv( GLenum pname, const GLfloat *params )
  1463. {
  1464.    GET_CONTEXT;
  1465.    CHECK_CONTEXT;
  1466.    (*CC->API.LightModelfv)( CC, pname, params );
  1467. }
  1468.  
  1469.  
  1470. void glLightModeliv( GLenum pname, const GLint *params )
  1471. {
  1472.    GLfloat fparam[4];
  1473.    GET_CONTEXT;
  1474.    CHECK_CONTEXT;
  1475.  
  1476.    switch (pname) {
  1477.       case GL_LIGHT_MODEL_AMBIENT:
  1478.          fparam[0] = INT_TO_FLOAT( params[0] );
  1479.          fparam[1] = INT_TO_FLOAT( params[1] );
  1480.          fparam[2] = INT_TO_FLOAT( params[2] );
  1481.          fparam[3] = INT_TO_FLOAT( params[3] );
  1482.          break;
  1483.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1484.       case GL_LIGHT_MODEL_TWO_SIDE:
  1485.          fparam[0] = (GLfloat) params[0];
  1486.          break;
  1487.       default:
  1488.          /* Error will be caught later in gl_LightModelfv */
  1489.          ;
  1490.    }
  1491.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1492. }
  1493.  
  1494.  
  1495. void glLineWidth( GLfloat width )
  1496. {
  1497.    GET_CONTEXT;
  1498.    CHECK_CONTEXT;
  1499.    (*CC->API.LineWidth)(CC, width);
  1500. }
  1501.  
  1502.  
  1503. void glLineStipple( GLint factor, GLushort pattern )
  1504. {
  1505.    GET_CONTEXT;
  1506.    CHECK_CONTEXT;
  1507.    (*CC->API.LineStipple)(CC, factor, pattern);
  1508. }
  1509.  
  1510.  
  1511. void glListBase( GLuint base )
  1512. {
  1513.    GET_CONTEXT;
  1514.    CHECK_CONTEXT;
  1515.    (*CC->API.ListBase)(CC, base);
  1516. }
  1517.  
  1518.  
  1519. void glLoadIdentity( void )
  1520. {
  1521.    static GLfloat identity[16] = {
  1522.       1.0, 0.0, 0.0, 0.0,
  1523.       0.0, 1.0, 0.0, 0.0,
  1524.       0.0, 0.0, 1.0, 0.0,
  1525.       0.0, 0.0, 0.0, 1.0
  1526.    };
  1527.    GET_CONTEXT;
  1528.    CHECK_CONTEXT;
  1529.    (*CC->API.LoadMatrixf)( CC, identity );
  1530. }
  1531.  
  1532.  
  1533. void glLoadMatrixd( const GLdouble *m )
  1534. {
  1535.    GLfloat fm[16];
  1536.    GLuint i;
  1537.    GET_CONTEXT;
  1538.    CHECK_CONTEXT;
  1539.  
  1540.    for (i=0;i<16;i++) {
  1541.       fm[i] = (GLfloat) m[i];
  1542.    }
  1543.  
  1544.    (*CC->API.LoadMatrixf)( CC, fm );
  1545. }
  1546.  
  1547.  
  1548. void glLoadMatrixf( const GLfloat *m )
  1549. {
  1550.    GET_CONTEXT;
  1551.    CHECK_CONTEXT;
  1552.    (*CC->API.LoadMatrixf)( CC, m );
  1553. }
  1554.  
  1555.  
  1556. void glLoadName( GLuint name )
  1557. {
  1558.    GET_CONTEXT;
  1559.    CHECK_CONTEXT;
  1560.    (*CC->API.LoadName)(CC, name);
  1561. }
  1562.  
  1563.  
  1564. void glLogicOp( GLenum opcode )
  1565. {
  1566.    GET_CONTEXT;
  1567.    CHECK_CONTEXT;
  1568.    (*CC->API.LogicOp)(CC, opcode);
  1569. }
  1570.  
  1571.  
  1572.  
  1573. void glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
  1574.               GLint order, const GLdouble *points )
  1575. {
  1576.    GLfloat *pnts;
  1577.    GLboolean retain;
  1578.    GET_CONTEXT;
  1579.    CHECK_CONTEXT;
  1580.  
  1581.    pnts = gl_copy_map_points1d( target, stride, order, points );
  1582.    retain = CC->CompileFlag;
  1583.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1584. }
  1585.  
  1586.  
  1587. void glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  1588.               GLint order, const GLfloat *points )
  1589. {
  1590.    GLfloat *pnts;
  1591.    GLboolean retain;
  1592.    GET_CONTEXT;
  1593.    CHECK_CONTEXT;
  1594.  
  1595.    pnts = gl_copy_map_points1f( target, stride, order, points );
  1596.    retain = CC->CompileFlag;
  1597.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1598. }
  1599.  
  1600.  
  1601. void glMap2d( GLenum target,
  1602.               GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
  1603.               GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
  1604.               const GLdouble *points )
  1605. {
  1606.    GLfloat *pnts;
  1607.    GLboolean retain;
  1608.    GET_CONTEXT;
  1609.    CHECK_CONTEXT;
  1610.  
  1611.    pnts = gl_copy_map_points2d( target, ustride, uorder,
  1612.                                 vstride, vorder, points );
  1613.    retain = CC->CompileFlag;
  1614.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1615.                      v1, v2, vstride, vorder, pnts, retain );
  1616. }
  1617.  
  1618.  
  1619. void glMap2f( GLenum target,
  1620.               GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  1621.               GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  1622.               const GLfloat *points )
  1623. {
  1624.    GLfloat *pnts;
  1625.    GLboolean retain;
  1626.    GET_CONTEXT;
  1627.    CHECK_CONTEXT;
  1628.  
  1629.    pnts = gl_copy_map_points2f( target, ustride, uorder,
  1630.                                 vstride, vorder, points );
  1631.    retain = CC->CompileFlag;
  1632.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1633.                      v1, v2, vstride, vorder, pnts, retain );
  1634. }
  1635.  
  1636.  
  1637. void glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
  1638. {
  1639.    GET_CONTEXT;
  1640.    CHECK_CONTEXT;
  1641.    (*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
  1642. }
  1643.  
  1644.  
  1645. void glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
  1646. {
  1647.    GET_CONTEXT;
  1648.    CHECK_CONTEXT;
  1649.    (*CC->API.MapGrid1f)( CC, un, u1, u2 );
  1650. }
  1651.  
  1652.  
  1653. void glMapGrid2d( GLint un, GLdouble u1, GLdouble u2,
  1654.           GLint vn, GLdouble v1, GLdouble v2 )
  1655. {
  1656.    GET_CONTEXT;
  1657.    CHECK_CONTEXT;
  1658.    (*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
  1659.                                   vn, (GLfloat) v1, (GLfloat) v2 );
  1660. }
  1661.  
  1662.  
  1663. void glMapGrid2f( GLint un, GLfloat u1, GLfloat u2,
  1664.           GLint vn, GLfloat v1, GLfloat v2 )
  1665. {
  1666.    GET_CONTEXT;
  1667.    CHECK_CONTEXT;
  1668.    (*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
  1669. }
  1670.  
  1671.  
  1672. void glMaterialf( GLenum face, GLenum pname, GLfloat param )
  1673. {
  1674.    GET_CONTEXT;
  1675.    CHECK_CONTEXT;
  1676.    (*CC->API.Materialfv)( CC, face, pname, ¶m );
  1677. }
  1678.  
  1679.  
  1680.  
  1681. void glMateriali( GLenum face, GLenum pname, GLint param )
  1682. {
  1683.    GLfloat fparam[4];
  1684.    GET_CONTEXT;
  1685.    CHECK_CONTEXT;
  1686.    fparam[0] = (GLfloat) param;
  1687.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1688. }
  1689.  
  1690.  
  1691. void glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
  1692. {
  1693.    GET_CONTEXT;
  1694.    CHECK_CONTEXT;
  1695.    (*CC->API.Materialfv)( CC, face, pname, params );
  1696. }
  1697.  
  1698.  
  1699. void glMaterialiv( GLenum face, GLenum pname, const GLint *params )
  1700. {
  1701.    GLfloat fparam[4];
  1702.    GET_CONTEXT;
  1703.    CHECK_CONTEXT;
  1704.    switch (pname) {
  1705.       case GL_AMBIENT:
  1706.       case GL_DIFFUSE:
  1707.       case GL_SPECULAR:
  1708.       case GL_EMISSION:
  1709.       case GL_AMBIENT_AND_DIFFUSE:
  1710.          fparam[0] = INT_TO_FLOAT( params[0] );
  1711.          fparam[1] = INT_TO_FLOAT( params[1] );
  1712.          fparam[2] = INT_TO_FLOAT( params[2] );
  1713.          fparam[3] = INT_TO_FLOAT( params[3] );
  1714.          break;
  1715.       case GL_SHININESS:
  1716.          fparam[0] = (GLfloat) params[0];
  1717.          break;
  1718.       case GL_COLOR_INDEXES:
  1719.          fparam[0] = (GLfloat) params[0];
  1720.          fparam[1] = (GLfloat) params[1];
  1721.          fparam[2] = (GLfloat) params[2];
  1722.          break;
  1723.       default:
  1724.          /* Error will be caught later in gl_Materialfv */
  1725.          ;
  1726.    }
  1727.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1728. }
  1729.  
  1730.  
  1731. void glMatrixMode( GLenum mode )
  1732. {
  1733.    GET_CONTEXT;
  1734.    CHECK_CONTEXT;
  1735.    (*CC->API.MatrixMode)( CC, mode );
  1736. }
  1737.  
  1738.  
  1739. void glMultMatrixd( const GLdouble *m )
  1740. {
  1741.    GLfloat fm[16];
  1742.    GLuint i;
  1743.    GET_CONTEXT;
  1744.    CHECK_CONTEXT;
  1745.  
  1746.    for (i=0;i<16;i++) {
  1747.       fm[i] = (GLfloat) m[i];
  1748.    }
  1749.  
  1750.    (*CC->API.MultMatrixf)( CC, fm );
  1751. }
  1752.  
  1753.  
  1754. void glMultMatrixf( const GLfloat *m )
  1755. {
  1756.    GET_CONTEXT;
  1757.    CHECK_CONTEXT;
  1758.    (*CC->API.MultMatrixf)( CC, m );
  1759. }
  1760.  
  1761.  
  1762. void glNewList( GLuint list, GLenum mode )
  1763. {
  1764.    GET_CONTEXT;
  1765.    CHECK_CONTEXT;
  1766.    (*CC->API.NewList)(CC, list, mode);
  1767. }
  1768.  
  1769. void glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
  1770. {
  1771.    GET_CONTEXT;
  1772.    (*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(nx),
  1773.                              BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz) );
  1774. }
  1775.  
  1776.  
  1777. void glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
  1778. {
  1779.    GLfloat fx, fy, fz;
  1780.    GET_CONTEXT;
  1781.    if (ABSD(nx)<0.00001)   fx = 0.0F;   else  fx = nx;
  1782.    if (ABSD(ny)<0.00001)   fy = 0.0F;   else  fy = ny;
  1783.    if (ABSD(nz)<0.00001)   fz = 0.0F;   else  fz = nz;
  1784.    (*CC->API.Normal3f)( CC, fx, fy, fz );
  1785. }
  1786.  
  1787.  
  1788. void glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
  1789. {
  1790.    GET_CONTEXT;
  1791. #ifdef SHORTCUT
  1792.    if (CC->CompileFlag) {
  1793.       (*CC->Save.Normal3f)( CC, nx, ny, nz );
  1794.       if (CC->ExecuteFlag) {
  1795.          CC->Current.Normal[0] = nx;
  1796.          CC->Current.Normal[1] = ny;
  1797.          CC->Current.Normal[2] = nz;
  1798.       }
  1799.    }
  1800.    else {
  1801.       /* Execute */
  1802.       CC->Current.Normal[0] = nx;
  1803.       CC->Current.Normal[1] = ny;
  1804.       CC->Current.Normal[2] = nz;
  1805.    }
  1806. #else
  1807.    (*CC->API.Normal3f)( CC, nx, ny, nz );
  1808. #endif
  1809. }
  1810.  
  1811.  
  1812. void glNormal3i( GLint nx, GLint ny, GLint nz )
  1813. {
  1814.    GET_CONTEXT;
  1815.    (*CC->API.Normal3f)( CC, INT_TO_FLOAT(nx),
  1816.                              INT_TO_FLOAT(ny), INT_TO_FLOAT(nz) );
  1817. }
  1818.  
  1819.  
  1820. void glNormal3s( GLshort nx, GLshort ny, GLshort nz )
  1821. {
  1822.    GET_CONTEXT;
  1823.    (*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(nx),
  1824.                              SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz) );
  1825. }
  1826.  
  1827.  
  1828. void glNormal3bv( const GLbyte *v )
  1829. {
  1830.    GET_CONTEXT;
  1831.    (*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(v[0]),
  1832.                              BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]) );
  1833. }
  1834.  
  1835.  
  1836. void glNormal3dv( const GLdouble *v )
  1837. {
  1838.    GLfloat fx, fy, fz;
  1839.    GET_CONTEXT;
  1840.    if (ABSD(v[0])<0.00001)   fx = 0.0F;   else  fx = v[0];
  1841.    if (ABSD(v[1])<0.00001)   fy = 0.0F;   else  fy = v[1];
  1842.    if (ABSD(v[2])<0.00001)   fz = 0.0F;   else  fz = v[2];
  1843.    (*CC->API.Normal3f)( CC, fx, fy, fz );
  1844. }
  1845.  
  1846.  
  1847. void glNormal3fv( const GLfloat *v )
  1848. {
  1849.    GET_CONTEXT;
  1850. #ifdef SHORTCUT
  1851.         if (CC->CompileFlag) {
  1852.            (*CC->Save.Normal3fv)( CC, v );
  1853.            if (CC->ExecuteFlag) {
  1854.               CC->Current.Normal[0] = v[0];
  1855.               CC->Current.Normal[1] = v[1];
  1856.               CC->Current.Normal[2] = v[2];
  1857.            }
  1858.         }
  1859.         else {
  1860.            /* Execute */
  1861.            GLfloat *n = CC->Current.Normal;
  1862.            n[0] = v[0];
  1863.            n[1] = v[1];
  1864.            n[2] = v[2];
  1865.         }
  1866. #else
  1867.    (*CC->API.Normal3fv)( CC, v );
  1868. #endif
  1869. }
  1870.  
  1871.  
  1872. void glNormal3iv( const GLint *v )
  1873. {
  1874.    GET_CONTEXT;
  1875.    (*CC->API.Normal3f)( CC, INT_TO_FLOAT(v[0]),
  1876.                              INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]) );
  1877. }
  1878.  
  1879.  
  1880. void glNormal3sv( const GLshort *v )
  1881. {
  1882.    GET_CONTEXT;
  1883.    (*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(v[0]),
  1884.                              SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]) );
  1885. }
  1886.  
  1887.  
  1888. void glNormalPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
  1889. {
  1890.    GET_CONTEXT;
  1891.    CHECK_CONTEXT;
  1892.    (*CC->API.NormalPointer)(CC, type, stride, ptr);
  1893. }
  1894.  
  1895.  
  1896. void glOrtho( GLdouble left, GLdouble right,
  1897.               GLdouble bottom, GLdouble top,
  1898.               GLdouble nearval, GLdouble farval )
  1899. {
  1900.    GLfloat x, y, z;
  1901.    GLfloat tx, ty, tz;
  1902.    GLfloat m[16];
  1903.    GET_CONTEXT;
  1904.    CHECK_CONTEXT;
  1905.  
  1906.    x = 2.0 / (right-left);
  1907.    y = 2.0 / (top-bottom);
  1908.    z = -2.0 / (farval-nearval);
  1909.    tx = -(right+left) / (right-left);
  1910.    ty = -(top+bottom) / (top-bottom);
  1911.    tz = -(farval+nearval) / (farval-nearval);
  1912.  
  1913. #define M(row,col)  m[col*4+row]
  1914.    M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = 0.0F;  M(0,3) = tx;
  1915.    M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = 0.0F;  M(1,3) = ty;
  1916.    M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = z;     M(2,3) = tz;
  1917.    M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = 0.0F;  M(3,3) = 1.0F;
  1918. #undef M
  1919.  
  1920.    (*CC->API.MultMatrixf)( CC, m );
  1921. }
  1922.  
  1923.  
  1924. void glPassThrough( GLfloat token )
  1925. {
  1926.    GET_CONTEXT;
  1927.    CHECK_CONTEXT;
  1928.    (*CC->API.PassThrough)(CC, token);
  1929. }
  1930.  
  1931.  
  1932. void glPixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
  1933. {
  1934.    GET_CONTEXT;
  1935.    CHECK_CONTEXT;
  1936.    (*CC->API.PixelMapfv)( CC, map, mapsize, values );
  1937. }
  1938.  
  1939.  
  1940. void glPixelMapuiv( GLenum map, GLint mapsize, const GLuint *values )
  1941. {
  1942.    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
  1943.    GLuint i;
  1944.    GET_CONTEXT;
  1945.    CHECK_CONTEXT;
  1946.  
  1947.    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
  1948.       for (i=0;i<mapsize;i++) {
  1949.     fvalues[i] = (GLfloat) values[i];
  1950.       }
  1951.    }
  1952.    else {
  1953.       for (i=0;i<mapsize;i++) {
  1954.     fvalues[i] = UINT_TO_FLOAT( values[i] );
  1955.       }
  1956.    }
  1957.    (*CC->API.PixelMapfv)( CC, map, mapsize, fvalues );
  1958. }
  1959.  
  1960.  
  1961.  
  1962. void glPixelMapusv( GLenum map, GLint mapsize, const GLushort *values )
  1963. {
  1964.    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
  1965.    GLuint i;
  1966.    GET_CONTEXT;
  1967.    CHECK_CONTEXT;
  1968.  
  1969.    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
  1970.       for (i=0;i<mapsize;i++) {
  1971.     fvalues[i] = (GLfloat) values[i];
  1972.       }
  1973.    }
  1974.    else {
  1975.       for (i=0;i<mapsize;i++) {
  1976.     fvalues[i] = USHORT_TO_FLOAT( values[i] );
  1977.       }
  1978.    }
  1979.    (*CC->API.PixelMapfv)( CC, map, mapsize, fvalues );
  1980. }
  1981.  
  1982.  
  1983. void glPixelStoref( GLenum pname, GLfloat param )
  1984. {
  1985.    GET_CONTEXT;
  1986.    CHECK_CONTEXT;
  1987.    (*CC->API.PixelStorei)( CC, pname, (GLint) param );
  1988. }
  1989.  
  1990.  
  1991. void glPixelStorei( GLenum pname, GLint param )
  1992. {
  1993.    GET_CONTEXT;
  1994.    CHECK_CONTEXT;
  1995.    (*CC->API.PixelStorei)( CC, pname, param );
  1996. }
  1997.  
  1998.  
  1999. void glPixelTransferf( GLenum pname, GLfloat param )
  2000. {
  2001.    GET_CONTEXT;
  2002.    CHECK_CONTEXT;
  2003.    (*CC->API.PixelTransferf)(CC, pname, param);
  2004. }
  2005.  
  2006.  
  2007. void glPixelTransferi( GLenum pname, GLint param )
  2008. {
  2009.    GET_CONTEXT;
  2010.    CHECK_CONTEXT;
  2011.    (*CC->API.PixelTransferf)(CC, pname, (GLfloat) param);
  2012. }
  2013.  
  2014.  
  2015. void glPixelZoom( GLfloat xfactor, GLfloat yfactor )
  2016. {
  2017.    GET_CONTEXT;
  2018.    CHECK_CONTEXT;
  2019.    (*CC->API.PixelZoom)(CC, xfactor, yfactor);
  2020. }
  2021.  
  2022.  
  2023. void glPointSize( GLfloat size )
  2024. {
  2025.    GET_CONTEXT;
  2026.    CHECK_CONTEXT;
  2027.    (*CC->API.PointSize)(CC, size);
  2028. }
  2029.  
  2030.  
  2031. void glPolygonMode( GLenum face, GLenum mode )
  2032. {
  2033.    GET_CONTEXT;
  2034.    CHECK_CONTEXT;
  2035.    (*CC->API.PolygonMode)(CC, face, mode);
  2036. }
  2037.  
  2038.  
  2039. void glPolygonOffset( GLfloat factor, GLfloat units )
  2040. {
  2041.    GET_CONTEXT;
  2042.    CHECK_CONTEXT;
  2043.    (*CC->API.PolygonOffset)( CC, factor, units );
  2044. }
  2045.  
  2046.  
  2047. #ifdef GL_EXT_polygon_offset
  2048. void glPolygonOffsetEXT( GLfloat factor, GLfloat bias )
  2049. {
  2050.    glPolygonOffset( factor, bias * DEPTH_SCALE );
  2051. }
  2052. #endif
  2053.  
  2054.  
  2055. void glPolygonStipple( const GLubyte *mask )
  2056. {
  2057.    GET_CONTEXT;
  2058.    CHECK_CONTEXT;
  2059.    (*CC->API.PolygonStipple)(CC, mask);
  2060. }
  2061.  
  2062.  
  2063. void glPopAttrib( void )
  2064. {
  2065.    GET_CONTEXT;
  2066.    CHECK_CONTEXT;
  2067.    (*CC->API.PopAttrib)(CC);
  2068. }
  2069.  
  2070.  
  2071. void glPopClientAttrib( void )
  2072. {
  2073.    GET_CONTEXT;
  2074.    CHECK_CONTEXT;
  2075.    (*CC->API.PopClientAttrib)(CC);
  2076. }
  2077.  
  2078.  
  2079. void glPopMatrix( void )
  2080. {
  2081.    GET_CONTEXT;
  2082.    CHECK_CONTEXT;
  2083.    (*CC->API.PopMatrix)( CC );
  2084. }
  2085.  
  2086.  
  2087. void glPopName( void )
  2088. {
  2089.    GET_CONTEXT;
  2090.    CHECK_CONTEXT;
  2091.    (*CC->API.PopName)(CC);
  2092. }
  2093.  
  2094.  
  2095. void glPrioritizeTextures( GLsizei n, const GLuint *textures,
  2096.                            const GLclampf *priorities )
  2097. {
  2098.    GET_CONTEXT;
  2099.    CHECK_CONTEXT;
  2100.    (*CC->API.PrioritizeTextures)(CC, n, textures, priorities);
  2101. }
  2102.  
  2103.  
  2104. void glPushMatrix( void )
  2105. {
  2106.    GET_CONTEXT;
  2107.    CHECK_CONTEXT;
  2108.    (*CC->API.PushMatrix)( CC );
  2109. }
  2110.  
  2111.  
  2112. void glRasterPos2d( GLdouble x, GLdouble y )
  2113. {
  2114.    GET_CONTEXT;
  2115.    CHECK_CONTEXT;
  2116.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  2117. }
  2118.  
  2119.  
  2120. void glRasterPos2f( GLfloat x, GLfloat y )
  2121. {
  2122.    GET_CONTEXT;
  2123.    CHECK_CONTEXT;
  2124.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  2125. }
  2126.  
  2127.  
  2128. void glRasterPos2i( GLint x, GLint y )
  2129. {
  2130.    GET_CONTEXT;
  2131.    CHECK_CONTEXT;
  2132.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  2133. }
  2134.  
  2135.  
  2136. void glRasterPos2s( GLshort x, GLshort y )
  2137. {
  2138.    GET_CONTEXT;
  2139.    CHECK_CONTEXT;
  2140.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  2141. }
  2142.  
  2143.  
  2144. void glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
  2145. {
  2146.    GET_CONTEXT;
  2147.    CHECK_CONTEXT;
  2148.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  2149. }
  2150.  
  2151.  
  2152. void glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
  2153. {
  2154.    GET_CONTEXT;
  2155.    CHECK_CONTEXT;
  2156.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  2157. }
  2158.  
  2159.  
  2160. void glRasterPos3i( GLint x, GLint y, GLint z )
  2161. {
  2162.    GET_CONTEXT;
  2163.    CHECK_CONTEXT;
  2164.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  2165. }
  2166.  
  2167.  
  2168. void glRasterPos3s( GLshort x, GLshort y, GLshort z )
  2169. {
  2170.    GET_CONTEXT;
  2171.    CHECK_CONTEXT;
  2172.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  2173. }
  2174.  
  2175.  
  2176. void glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
  2177. {
  2178.    GET_CONTEXT;
  2179.    CHECK_CONTEXT;
  2180.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
  2181.                                (GLfloat) z, (GLfloat) w );
  2182. }
  2183.  
  2184.  
  2185. void glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  2186. {
  2187.    GET_CONTEXT;
  2188.    CHECK_CONTEXT;
  2189.    (*CC->API.RasterPos4f)( CC, x, y, z, w );
  2190. }
  2191.  
  2192.  
  2193. void glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
  2194. {
  2195.    GET_CONTEXT;
  2196.    CHECK_CONTEXT;
  2197.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
  2198.                                (GLfloat) z, (GLfloat) w );
  2199. }
  2200.  
  2201.  
  2202. void glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
  2203. {
  2204.    GET_CONTEXT;
  2205.    CHECK_CONTEXT;
  2206.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
  2207.                                (GLfloat) z, (GLfloat) w );
  2208. }
  2209.  
  2210.  
  2211. void glRasterPos2dv( const GLdouble *v )
  2212. {
  2213.    GET_CONTEXT;
  2214.    CHECK_CONTEXT;
  2215.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  2216. }
  2217.  
  2218.  
  2219. void glRasterPos2fv( const GLfloat *v )
  2220. {
  2221.    GET_CONTEXT;
  2222.    CHECK_CONTEXT;
  2223.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  2224. }
  2225.  
  2226.  
  2227. void glRasterPos2iv( const GLint *v )
  2228. {
  2229.    GET_CONTEXT;
  2230.    CHECK_CONTEXT;
  2231.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  2232. }
  2233.  
  2234.  
  2235. void glRasterPos2sv( const GLshort *v )
  2236. {
  2237.    GET_CONTEXT;
  2238.    CHECK_CONTEXT;
  2239.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  2240. }
  2241.  
  2242.  
  2243. /*** 3 element vector ***/
  2244.  
  2245. void glRasterPos3dv( const GLdouble *v )
  2246. {
  2247.    GET_CONTEXT;
  2248.    CHECK_CONTEXT;
  2249.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2250.                                (GLfloat) v[2], 1.0F );
  2251. }
  2252.  
  2253.  
  2254. void glRasterPos3fv( const GLfloat *v )
  2255. {
  2256.    GET_CONTEXT;
  2257.    CHECK_CONTEXT;
  2258.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2259.                                (GLfloat) v[2], 1.0F );
  2260. }
  2261.  
  2262.  
  2263. void glRasterPos3iv( const GLint *v )
  2264. {
  2265.    GET_CONTEXT;
  2266.    CHECK_CONTEXT;
  2267.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2268.                                (GLfloat) v[2], 1.0F );
  2269. }
  2270.  
  2271.  
  2272. void glRasterPos3sv( const GLshort *v )
  2273. {
  2274.    GET_CONTEXT;
  2275.    CHECK_CONTEXT;
  2276.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2277.                                (GLfloat) v[2], 1.0F );
  2278. }
  2279.  
  2280.  
  2281. void glRasterPos4dv( const GLdouble *v )
  2282. {
  2283.    GET_CONTEXT;
  2284.    CHECK_CONTEXT;
  2285.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2286.                                (GLfloat) v[2], (GLfloat) v[3] );
  2287. }
  2288.  
  2289.  
  2290. void glRasterPos4fv( const GLfloat *v )
  2291. {
  2292.    GET_CONTEXT;
  2293.    CHECK_CONTEXT;
  2294.    (*CC->API.RasterPos4f)( CC, v[0], v[1], v[2], v[3] );
  2295. }
  2296.  
  2297.  
  2298. void glRasterPos4iv( const GLint *v )
  2299. {
  2300.    GET_CONTEXT;
  2301.    CHECK_CONTEXT;
  2302.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2303.                                (GLfloat) v[2], (GLfloat) v[3] );
  2304. }
  2305.  
  2306.  
  2307. void glRasterPos4sv( const GLshort *v )
  2308. {
  2309.    GET_CONTEXT;
  2310.    CHECK_CONTEXT;
  2311.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2312.                                (GLfloat) v[2], (GLfloat) v[3] );
  2313. }
  2314.  
  2315.  
  2316. void glReadBuffer( GLenum mode )
  2317. {
  2318.    GET_CONTEXT;
  2319.    CHECK_CONTEXT;
  2320.    (*CC->API.ReadBuffer)( CC, mode );
  2321. }
  2322.  
  2323.  
  2324. void glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
  2325.            GLenum format, GLenum type, GLvoid *pixels )
  2326. {
  2327.    GET_CONTEXT;
  2328.    CHECK_CONTEXT;
  2329.    (*CC->API.ReadPixels)( CC, x, y, width, height, format, type, pixels );
  2330. }
  2331.  
  2332.  
  2333. void glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
  2334. {
  2335.    GET_CONTEXT;
  2336.    CHECK_CONTEXT;
  2337.    (*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
  2338.                     (GLfloat) x2, (GLfloat) y2 );
  2339. }
  2340.  
  2341.  
  2342. void glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
  2343. {
  2344.    GET_CONTEXT;
  2345.    CHECK_CONTEXT;
  2346.    (*CC->API.Rectf)( CC, x1, y1, x2, y2 );
  2347. }
  2348.  
  2349.  
  2350. void glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
  2351. {
  2352.    GET_CONTEXT;
  2353.    CHECK_CONTEXT;
  2354.    (*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
  2355.                          (GLfloat) x2, (GLfloat) y2 );
  2356. }
  2357.  
  2358.  
  2359. void glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
  2360. {
  2361.    GET_CONTEXT;
  2362.    CHECK_CONTEXT;
  2363.    (*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
  2364.                      (GLfloat) x2, (GLfloat) y2 );
  2365. }
  2366.  
  2367.  
  2368. void glRectdv( const GLdouble *v1, const GLdouble *v2 )
  2369. {
  2370.    GET_CONTEXT;
  2371.    CHECK_CONTEXT;
  2372.    (*CC->API.Rectf)(CC, (GLfloat) v1[0], (GLfloat) v1[1],
  2373.                     (GLfloat) v2[0], (GLfloat) v2[1]);
  2374. }
  2375.  
  2376.  
  2377. void glRectfv( const GLfloat *v1, const GLfloat *v2 )
  2378. {
  2379.    GET_CONTEXT;
  2380.    CHECK_CONTEXT;
  2381.    (*CC->API.Rectf)(CC, v1[0], v1[1], v2[0], v2[1]);
  2382. }
  2383.  
  2384.  
  2385. void glRectiv( const GLint *v1, const GLint *v2 )
  2386. {
  2387.    GET_CONTEXT;
  2388.    CHECK_CONTEXT;
  2389.    (*CC->API.Rectf)( CC, (GLfloat) v1[0], (GLfloat) v1[1],
  2390.                      (GLfloat) v2[0], (GLfloat) v2[1] );
  2391. }
  2392.  
  2393.  
  2394. void glRectsv( const GLshort *v1, const GLshort *v2 )
  2395. {
  2396.    GET_CONTEXT;
  2397.    CHECK_CONTEXT;
  2398.    (*CC->API.Rectf)(CC, (GLfloat) v1[0], (GLfloat) v1[1],
  2399.         (GLfloat) v2[0], (GLfloat) v2[1]);
  2400. }
  2401.  
  2402.  
  2403. void glScissor( GLint x, GLint y, GLsizei width, GLsizei height)
  2404. {
  2405.    GET_CONTEXT;
  2406.    CHECK_CONTEXT;
  2407.    (*CC->API.Scissor)(CC, x, y, width, height);
  2408. }
  2409.  
  2410.  
  2411. GLboolean glIsEnabled( GLenum cap )
  2412. {
  2413.    GET_CONTEXT;
  2414.    CHECK_CONTEXT_RETURN(GL_FALSE);
  2415.    return (*CC->API.IsEnabled)( CC, cap );
  2416. }
  2417.  
  2418.  
  2419.  
  2420. void glPushAttrib( GLbitfield mask )
  2421. {
  2422.    GET_CONTEXT;
  2423.    CHECK_CONTEXT;
  2424.    (*CC->API.PushAttrib)(CC, mask);
  2425. }
  2426.  
  2427.  
  2428. void glPushClientAttrib( GLbitfield mask )
  2429. {
  2430.    GET_CONTEXT;
  2431.    CHECK_CONTEXT;
  2432.    (*CC->API.PushClientAttrib)(CC, mask);
  2433. }
  2434.  
  2435.  
  2436. void glPushName( GLuint name )
  2437. {
  2438.    GET_CONTEXT;
  2439.    CHECK_CONTEXT;
  2440.    (*CC->API.PushName)(CC, name);
  2441. }
  2442.  
  2443.  
  2444. GLint glRenderMode( GLenum mode )
  2445. {
  2446.    GET_CONTEXT;
  2447.    CHECK_CONTEXT_RETURN(0);
  2448.    return (*CC->API.RenderMode)(CC, mode);
  2449. }
  2450.  
  2451.  
  2452. void glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
  2453. {
  2454.    GET_CONTEXT;
  2455.    CHECK_CONTEXT;
  2456.    (*CC->API.Rotatef)( CC, (GLfloat) angle,
  2457.                        (GLfloat) x, (GLfloat) y, (GLfloat) z );
  2458. }
  2459.  
  2460.  
  2461. void glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
  2462. {
  2463.    GET_CONTEXT;
  2464.    CHECK_CONTEXT;
  2465.    (*CC->API.Rotatef)( CC, angle, x, y, z );
  2466. }
  2467.  
  2468.  
  2469. void glSelectBuffer( GLsizei size, GLuint *buffer )
  2470. {
  2471.    GET_CONTEXT;
  2472.    CHECK_CONTEXT;
  2473.    (*CC->API.SelectBuffer)(CC, size, buffer);
  2474. }
  2475.  
  2476.  
  2477. void glScaled( GLdouble x, GLdouble y, GLdouble z )
  2478. {
  2479.    GET_CONTEXT;
  2480.    CHECK_CONTEXT;
  2481.    (*CC->API.Scalef)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
  2482. }
  2483.  
  2484.  
  2485. void glScalef( GLfloat x, GLfloat y, GLfloat z )
  2486. {
  2487.    GET_CONTEXT;
  2488.    CHECK_CONTEXT;
  2489.    (*CC->API.Scalef)( CC, x, y, z );
  2490. }
  2491.  
  2492.  
  2493. void glShadeModel( GLenum mode )
  2494. {
  2495.    GET_CONTEXT;
  2496.    CHECK_CONTEXT;
  2497.    (*CC->API.ShadeModel)(CC, mode);
  2498. }
  2499.  
  2500.  
  2501. void glStencilFunc( GLenum func, GLint ref, GLuint mask )
  2502. {
  2503.    GET_CONTEXT;
  2504.    CHECK_CONTEXT;
  2505.    (*CC->API.StencilFunc)(CC, func, ref, mask);
  2506. }
  2507.  
  2508.  
  2509. void glStencilMask( GLuint mask )
  2510. {
  2511.    GET_CONTEXT;
  2512.    CHECK_CONTEXT;
  2513.    (*CC->API.StencilMask)(CC, mask);
  2514. }
  2515.  
  2516.  
  2517. void glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
  2518. {
  2519.    GET_CONTEXT;
  2520.    CHECK_CONTEXT;
  2521.    (*CC->API.StencilOp)(CC, fail, zfail, zpass);
  2522. }
  2523.  
  2524.  
  2525. void glTexCoord1d( GLdouble s )
  2526. {
  2527.    GET_CONTEXT;
  2528.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
  2529. }
  2530.  
  2531.  
  2532. void glTexCoord1f( GLfloat s )
  2533. {
  2534.    GET_CONTEXT;
  2535.    (*CC->API.TexCoord4f)( CC, s, 0.0, 0.0, 1.0 );
  2536. }
  2537.  
  2538.  
  2539. void glTexCoord1i( GLint s )
  2540. {
  2541.    GET_CONTEXT;
  2542.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
  2543. }
  2544.  
  2545.  
  2546. void glTexCoord1s( GLshort s )
  2547. {
  2548.    GET_CONTEXT;
  2549.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
  2550. }
  2551.  
  2552.  
  2553. void glTexCoord2d( GLdouble s, GLdouble t )
  2554. {
  2555.    GET_CONTEXT;
  2556.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t, 0.0, 1.0 );
  2557. }
  2558.  
  2559.  
  2560. void glTexCoord2f( GLfloat s, GLfloat t )
  2561. {
  2562.    GET_CONTEXT;
  2563. #ifdef SHORTCUT
  2564.         if (CC->CompileFlag) {
  2565.            (*CC->Save.TexCoord4f)( CC, s, t, 0.0F, 1.0F );
  2566.            if (CC->ExecuteFlag) {
  2567.               CC->Current.TexCoord[0] = s;
  2568.               CC->Current.TexCoord[1] = t;
  2569.               CC->Current.TexCoord[2] = 0.0F;
  2570.               CC->Current.TexCoord[3] = 1.0F;
  2571.            }
  2572.         }
  2573.         else {
  2574.            /* Execute */
  2575.            GLfloat *tex = CC->Current.TexCoord;
  2576.            tex[0] = s;
  2577.            tex[1] = t;
  2578.            tex[2] = 0.0F;
  2579.            tex[3] = 1.0F;
  2580.         }
  2581. #else
  2582.    (*CC->API.TexCoord4f)( CC, s, tex, 0.0, 1.0 );
  2583. #endif
  2584. }
  2585.  
  2586.  
  2587. void glTexCoord2i( GLint s, GLint t )
  2588. {
  2589.    GET_CONTEXT;
  2590.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t, 0.0, 1.0 );
  2591. }
  2592.  
  2593.  
  2594. void glTexCoord2s( GLshort s, GLshort t )
  2595. {
  2596.    GET_CONTEXT;
  2597.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t, 0.0, 1.0 );
  2598. }
  2599.  
  2600.  
  2601. void glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
  2602. {
  2603.    GET_CONTEXT;
  2604.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t, (GLfloat) r, 1.0 );
  2605. }
  2606.  
  2607.  
  2608. void glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
  2609. {
  2610.    GET_CONTEXT;
  2611.    (*CC->API.TexCoord4f)( CC, s, t, r, 1.0 );
  2612. }
  2613.  
  2614.  
  2615. void glTexCoord3i( GLint s, GLint t, GLint r )
  2616. {
  2617.    GET_CONTEXT;
  2618.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  2619.                                (GLfloat) r, 1.0 );
  2620. }
  2621.  
  2622.  
  2623. void glTexCoord3s( GLshort s, GLshort t, GLshort r )
  2624. {
  2625.    GET_CONTEXT;
  2626.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  2627.                                (GLfloat) r, 1.0 );
  2628. }
  2629.  
  2630.  
  2631. void glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
  2632. {
  2633.    GET_CONTEXT;
  2634.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  2635.                                (GLfloat) r, (GLfloat) q );
  2636. }
  2637.  
  2638.  
  2639. void glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
  2640. {
  2641.    GET_CONTEXT;
  2642.    (*CC->API.TexCoord4f)( CC, s, t, r, q );
  2643. }
  2644.  
  2645.  
  2646. void glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
  2647. {
  2648.    GET_CONTEXT;
  2649.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  2650.                                (GLfloat) r, (GLfloat) q );
  2651. }
  2652.  
  2653.  
  2654. void glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
  2655. {
  2656.    GET_CONTEXT;
  2657.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  2658.                                (GLfloat) r, (GLfloat) q );
  2659. }
  2660.  
  2661.  
  2662. void glTexCoord1dv( const GLdouble *v )
  2663. {
  2664.    GET_CONTEXT;
  2665.    (*CC->API.TexCoord4f)( CC, (GLfloat) *v, 0.0, 0.0, 1.0 );
  2666. }
  2667.  
  2668.  
  2669. void glTexCoord1fv( const GLfloat *v )
  2670. {
  2671.    GET_CONTEXT;
  2672.    (*CC->API.TexCoord4f)( CC, *v, 0.0, 0.0, 1.0 );
  2673. }
  2674.  
  2675.  
  2676. void glTexCoord1iv( const GLint *v )
  2677. {
  2678.    GET_CONTEXT;
  2679.    (*CC->API.TexCoord4f)( CC, *v, 0.0, 0.0, 1.0 );
  2680. }
  2681.  
  2682.  
  2683. void glTexCoord1sv( const GLshort *v )
  2684. {
  2685.    GET_CONTEXT;
  2686.    (*CC->API.TexCoord4f)( CC, (GLfloat) *v, 0.0, 0.0, 1.0 );
  2687. }
  2688.  
  2689.  
  2690. void glTexCoord2dv( const GLdouble *v )
  2691. {
  2692.    GET_CONTEXT;
  2693.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0, 1.0 );
  2694. }
  2695.  
  2696.  
  2697. void glTexCoord2fv( const GLfloat *v )
  2698. {
  2699.    GET_CONTEXT;
  2700.    (*CC->API.TexCoord4f)( CC, v[0], v[1], 0.0, 1.0 );
  2701. }
  2702.  
  2703.  
  2704. void glTexCoord2iv( const GLint *v )
  2705. {
  2706.    GET_CONTEXT;
  2707.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0, 1.0 );
  2708. }
  2709.  
  2710.  
  2711. void glTexCoord2sv( const GLshort *v )
  2712. {
  2713.    GET_CONTEXT;
  2714.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0, 1.0 );
  2715. }
  2716.  
  2717.  
  2718. void glTexCoord3dv( const GLdouble *v )
  2719. {
  2720.    GET_CONTEXT;
  2721.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2722.                                (GLfloat) v[2], 1.0 );
  2723. }
  2724.  
  2725.  
  2726. void glTexCoord3fv( const GLfloat *v )
  2727. {
  2728.    GET_CONTEXT;
  2729.    (*CC->API.TexCoord4f)( CC, v[0], v[1], v[2], 1.0 );
  2730. }
  2731.  
  2732.  
  2733. void glTexCoord3iv( const GLint *v )
  2734. {
  2735.    GET_CONTEXT;
  2736.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2737.                           (GLfloat) v[2], 1.0 );
  2738. }
  2739.  
  2740.  
  2741. void glTexCoord3sv( const GLshort *v )
  2742. {
  2743.    GET_CONTEXT;
  2744.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2745.                                (GLfloat) v[2], 1.0 );
  2746. }
  2747.  
  2748.  
  2749. void glTexCoord4dv( const GLdouble *v )
  2750. {
  2751.    GET_CONTEXT;
  2752.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2753.                                (GLfloat) v[2], (GLfloat) v[3] );
  2754. }
  2755.  
  2756.  
  2757. void glTexCoord4fv( const GLfloat *v )
  2758. {
  2759.    GET_CONTEXT;
  2760.    (*CC->API.TexCoord4f)( CC, v[0], v[1], v[2], v[3] );
  2761. }
  2762.  
  2763.  
  2764. void glTexCoord4iv( const GLint *v )
  2765. {
  2766.    GET_CONTEXT;
  2767.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2768.                                (GLfloat) v[2], (GLfloat) v[3] );
  2769. }
  2770.  
  2771.  
  2772. void glTexCoord4sv( const GLshort *v )
  2773. {
  2774.    GET_CONTEXT;
  2775.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  2776.                                (GLfloat) v[2], (GLfloat) v[3] );
  2777. }
  2778.  
  2779.  
  2780. void glTexCoordPointer( GLint size, GLenum type, GLsizei stride,
  2781.                         const GLvoid *ptr )
  2782. {
  2783.    GET_CONTEXT;
  2784.    CHECK_CONTEXT;
  2785.    (*CC->API.TexCoordPointer)(CC, size, type, stride, ptr);
  2786. }
  2787.  
  2788.  
  2789. void glTexGend( GLenum coord, GLenum pname, GLdouble param )
  2790. {
  2791.    GLfloat p = (GLfloat) param;
  2792.    GET_CONTEXT;
  2793.    CHECK_CONTEXT;
  2794.    (*CC->API.TexGenfv)( CC, coord, pname, &p );
  2795. }
  2796.  
  2797.  
  2798. void glTexGenf( GLenum coord, GLenum pname, GLfloat param )
  2799. {
  2800.    GET_CONTEXT;
  2801.    CHECK_CONTEXT;
  2802.    (*CC->API.TexGenfv)( CC, coord, pname, ¶m );
  2803. }
  2804.  
  2805.  
  2806. void glTexGeni( GLenum coord, GLenum pname, GLint param )
  2807. {
  2808.    GLfloat p = (GLfloat) param;
  2809.    GET_CONTEXT;
  2810.    CHECK_CONTEXT;
  2811.    (*CC->API.TexGenfv)( CC, coord, pname, &p );
  2812. }
  2813.  
  2814.  
  2815. void glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
  2816. {
  2817.    GLfloat p[4];
  2818.    GET_CONTEXT;
  2819.    CHECK_CONTEXT;
  2820.    p[0] = params[0];
  2821.    p[1] = params[1];
  2822.    p[2] = params[2];
  2823.    p[3] = params[3];
  2824.    (*CC->API.TexGenfv)( CC, coord, pname, p );
  2825. }
  2826.  
  2827.  
  2828. void glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
  2829. {
  2830.    GLfloat p[4];
  2831.    GET_CONTEXT;
  2832.    CHECK_CONTEXT;
  2833.    p[0] = params[0];
  2834.    p[1] = params[1];
  2835.    p[2] = params[2];
  2836.    p[3] = params[3];
  2837.    (*CC->API.TexGenfv)( CC, coord, pname, p );
  2838. }
  2839.  
  2840.  
  2841. void glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
  2842. {
  2843.    GET_CONTEXT;
  2844.    CHECK_CONTEXT;
  2845.    (*CC->API.TexGenfv)( CC, coord, pname, params );
  2846. }
  2847.  
  2848.  
  2849.  
  2850.  
  2851. void glTexEnvf( GLenum target, GLenum pname, GLfloat param )
  2852. {
  2853.    GET_CONTEXT;
  2854.    CHECK_CONTEXT;
  2855.    (*CC->API.TexEnvfv)( CC, target, pname, ¶m );
  2856. }
  2857.  
  2858.  
  2859.  
  2860. void glTexEnvi( GLenum target, GLenum pname, GLint param )
  2861. {
  2862.    GLfloat p = (GLfloat) param;
  2863.    GET_CONTEXT;
  2864.    CHECK_CONTEXT;
  2865.    (*CC->API.TexEnvfv)( CC, target, pname, &p );
  2866. }
  2867.  
  2868.  
  2869.  
  2870. void glTexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
  2871. {
  2872.    GET_CONTEXT;
  2873.    CHECK_CONTEXT;
  2874.    (*CC->API.TexEnvfv)( CC, target, pname, param );
  2875. }
  2876.  
  2877.  
  2878.  
  2879. void glTexEnviv( GLenum target, GLenum pname, const GLint *param )
  2880. {
  2881.    GLfloat p[4];
  2882.    p[0] = INT_TO_FLOAT( param[0] );
  2883.    p[1] = INT_TO_FLOAT( param[1] );
  2884.    p[2] = INT_TO_FLOAT( param[2] );
  2885.    p[3] = INT_TO_FLOAT( param[3] );
  2886.    GET_CONTEXT;
  2887.    CHECK_CONTEXT;
  2888.    (*CC->API.TexEnvfv)( CC, target, pname, p );
  2889. }
  2890.  
  2891.  
  2892. void glTexImage1D( GLenum target, GLint level, GLint internalformat,
  2893.                    GLsizei width, GLint border,
  2894.                    GLenum format, GLenum type, const GLvoid *pixels )
  2895. {
  2896.    struct gl_image *teximage;
  2897.    GLenum destType;
  2898.    GET_CONTEXT;
  2899.    CHECK_CONTEXT;
  2900.    if (type==GL_UNSIGNED_BYTE) {
  2901.       destType = GL_UNSIGNED_BYTE;
  2902.    }
  2903.    else if (type==GL_BITMAP) {
  2904.       destType = GL_BITMAP;
  2905.    }
  2906.    else {
  2907.       destType = GL_FLOAT;
  2908.    }
  2909.    teximage = gl_unpack_image( CC, width, 1, format, type,
  2910.                                destType, pixels, GL_FALSE );
  2911.    (*CC->API.TexImage1D)( CC, target, level, internalformat,
  2912.                           width, border, format, type, teximage );
  2913. }
  2914.  
  2915.  
  2916.  
  2917. void glTexImage2D( GLenum target, GLint level, GLint internalformat,
  2918.                    GLsizei width, GLsizei height, GLint border,
  2919.                    GLenum format, GLenum type, const GLvoid *pixels )
  2920. {
  2921.    struct gl_image *teximage;
  2922.    GLenum destType;
  2923.    GET_CONTEXT;
  2924.    CHECK_CONTEXT;
  2925.    if (type==GL_UNSIGNED_BYTE) {
  2926.       destType = GL_UNSIGNED_BYTE;
  2927.    }
  2928.    else if (type==GL_BITMAP) {
  2929.       destType = GL_BITMAP;
  2930.    }
  2931.    else {
  2932.       destType = GL_FLOAT;
  2933.    }
  2934.    teximage = gl_unpack_image( CC, width, height, format, type,
  2935.                                destType, pixels, GL_FALSE );
  2936.    (*CC->API.TexImage2D)( CC, target, level, internalformat,
  2937.                           width, height, border, format, type, teximage );
  2938. }
  2939.  
  2940.  
  2941. void glTexParameterf( GLenum target, GLenum pname, GLfloat param )
  2942. {
  2943.    GET_CONTEXT;
  2944.    CHECK_CONTEXT;
  2945.    (*CC->API.TexParameterfv)( CC, target, pname, ¶m );
  2946. }
  2947.  
  2948.  
  2949. void glTexParameteri( GLenum target, GLenum pname, GLint param )
  2950. {
  2951.    GLfloat fparam = param;
  2952.    GET_CONTEXT;
  2953.    CHECK_CONTEXT;
  2954.    (*CC->API.TexParameterfv)( CC, target, pname, &fparam );
  2955. }
  2956.  
  2957.  
  2958. void glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
  2959. {
  2960.    GET_CONTEXT;
  2961.    CHECK_CONTEXT;
  2962.    (*CC->API.TexParameterfv)( CC, target, pname, params );
  2963. }
  2964.  
  2965.  
  2966. void glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
  2967. {
  2968.    GLfloat p[4];
  2969.    GET_CONTEXT;
  2970.    CHECK_CONTEXT;
  2971.    if (pname==GL_TEXTURE_BORDER_COLOR) {
  2972.       p[0] = INT_TO_FLOAT( params[0] );
  2973.       p[1] = INT_TO_FLOAT( params[1] );
  2974.       p[2] = INT_TO_FLOAT( params[2] );
  2975.       p[3] = INT_TO_FLOAT( params[3] );
  2976.    }
  2977.    else {
  2978.       p[0] = (GLfloat) params[0];
  2979.       p[1] = (GLfloat) params[1];
  2980.       p[2] = (GLfloat) params[2];
  2981.       p[3] = (GLfloat) params[3];
  2982.    }
  2983.    (*CC->API.TexParameterfv)( CC, target, pname, p );
  2984. }
  2985.  
  2986.  
  2987. void glTexSubImage1D( GLenum target, GLint level, GLint xoffset,
  2988.                       GLsizei width, GLenum format,
  2989.                       GLenum type, const GLvoid *pixels )
  2990. {
  2991.    struct gl_image *image;
  2992.    GET_CONTEXT;
  2993.    CHECK_CONTEXT;
  2994.    image = gl_unpack_texsubimage( CC, width, 1, format, type, pixels );
  2995.    (*CC->API.TexSubImage1D)( CC, target, level, xoffset, width,
  2996.                              format, type, image );
  2997. }
  2998.  
  2999.  
  3000. void glTexSubImage2D( GLenum target, GLint level,
  3001.                       GLint xoffset, GLint yoffset,
  3002.                       GLsizei width, GLsizei height,
  3003.                       GLenum format, GLenum type,
  3004.                       const GLvoid *pixels )
  3005. {
  3006.    struct gl_image *image;
  3007.    GET_CONTEXT;
  3008.    CHECK_CONTEXT;
  3009.    image = gl_unpack_texsubimage( CC, width, height, format, type, pixels );
  3010.    (*CC->API.TexSubImage2D)( CC, target, level, xoffset, yoffset,
  3011.                              width, height, format, type, image );
  3012. }
  3013.  
  3014.  
  3015. void glTranslated( GLdouble x, GLdouble y, GLdouble z )
  3016. {
  3017.    GET_CONTEXT;
  3018.    CHECK_CONTEXT;
  3019.    (*CC->API.Translatef)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
  3020. }
  3021.  
  3022.  
  3023. void glTranslatef( GLfloat x, GLfloat y, GLfloat z )
  3024. {
  3025.    GET_CONTEXT;
  3026.    CHECK_CONTEXT;
  3027.    (*CC->API.Translatef)( CC, x, y, z );
  3028. }
  3029.  
  3030.  
  3031. void glVertex2d( GLdouble x, GLdouble y )
  3032. {
  3033.    GET_CONTEXT;
  3034.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  3035. }
  3036.  
  3037.  
  3038. void glVertex2f( GLfloat x, GLfloat y )
  3039. {
  3040.    GET_CONTEXT;
  3041.    (*CC->API.Vertex4f)( CC, x, y, 0.0F, 1.0F );
  3042. }
  3043.  
  3044.  
  3045. void glVertex2i( GLint x, GLint y )
  3046. {
  3047.    GET_CONTEXT;
  3048.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  3049. }
  3050.  
  3051.  
  3052. void glVertex2s( GLshort x, GLshort y )
  3053. {
  3054.    GET_CONTEXT;
  3055.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  3056. }
  3057.  
  3058.  
  3059. void glVertex3d( GLdouble x, GLdouble y, GLdouble z )
  3060. {
  3061.    GET_CONTEXT;
  3062.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  3063. }
  3064.  
  3065.  
  3066. void glVertex3f( GLfloat x, GLfloat y, GLfloat z )
  3067. {
  3068.    GET_CONTEXT;
  3069.    (*CC->API.Vertex4f)( CC, x, y, z, 1.0F );
  3070. }
  3071.  
  3072.  
  3073. void glVertex3i( GLint x, GLint y, GLint z )
  3074. {
  3075.    GET_CONTEXT;
  3076.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  3077. }
  3078.  
  3079.  
  3080. void glVertex3s( GLshort x, GLshort y, GLshort z )
  3081. {
  3082.    GET_CONTEXT;
  3083.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  3084. }
  3085.  
  3086.  
  3087. void glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
  3088. {
  3089.    GET_CONTEXT;
  3090.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
  3091.                             (GLfloat) z, (GLfloat) w );
  3092. }
  3093.  
  3094.  
  3095. void glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  3096. {
  3097.    GET_CONTEXT;
  3098.    (*CC->API.Vertex4f)( CC, x, y, z, w );
  3099. }
  3100.  
  3101.  
  3102. void glVertex4i( GLint x, GLint y, GLint z, GLint w )
  3103. {
  3104.    GET_CONTEXT;
  3105.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
  3106.                             (GLfloat) z, (GLfloat) w );
  3107. }
  3108.  
  3109.  
  3110. void glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
  3111. {
  3112.    GET_CONTEXT;
  3113.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
  3114.                             (GLfloat) z, (GLfloat) w );
  3115. }
  3116.  
  3117.  
  3118. void glVertex2dv( const GLdouble *v )
  3119. {
  3120.    GET_CONTEXT;
  3121.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  3122. }
  3123.  
  3124.  
  3125. void glVertex2fv( const GLfloat *v )
  3126. {
  3127.    GET_CONTEXT;
  3128.    (*CC->API.Vertex4f)( CC, v[0], v[1], 0.0F, 1.0F );
  3129. }
  3130.  
  3131.  
  3132. void glVertex2iv( const GLint *v )
  3133. {
  3134.    GET_CONTEXT;
  3135.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  3136. }
  3137.  
  3138.  
  3139. void glVertex2sv( const GLshort *v )
  3140. {
  3141.    GET_CONTEXT;
  3142.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  3143. }
  3144.  
  3145.  
  3146. void glVertex3dv( const GLdouble *v )
  3147. {
  3148.    GET_CONTEXT;
  3149.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  3150.                             (GLfloat) v[2], 1.0F );
  3151. }
  3152.  
  3153.  
  3154. void glVertex3fv( const GLfloat *v )
  3155. {
  3156.    GET_CONTEXT;
  3157.    (*CC->API.Vertex4f)( CC, v[0], v[1], v[2], 1.0F );
  3158. }
  3159.  
  3160.  
  3161. void glVertex3iv( const GLint *v )
  3162. {
  3163.    GET_CONTEXT;
  3164.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  3165.                             (GLfloat) v[2], 1.0F );
  3166. }
  3167.  
  3168.  
  3169. void glVertex3sv( const GLshort *v )
  3170. {
  3171.    GET_CONTEXT;
  3172.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  3173.                             (GLfloat) v[2], 1.0F );
  3174. }
  3175.  
  3176.  
  3177. void glVertex4dv( const GLdouble *v )
  3178. {
  3179.    GET_CONTEXT;
  3180.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  3181.                             (GLfloat) v[2], (GLfloat) v[3] );
  3182. }
  3183.  
  3184.  
  3185. void glVertex4fv( const GLfloat *v )
  3186. {
  3187.    GET_CONTEXT;
  3188.    (*CC->API.Vertex4f)( CC, v[0], v[1], v[2], v[3] );
  3189. }
  3190.  
  3191.  
  3192. void glVertex4iv( const GLint *v )
  3193. {
  3194.    GET_CONTEXT;
  3195.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  3196.                   (GLfloat) v[2], (GLfloat) v[3] );
  3197. }
  3198.  
  3199.  
  3200. void glVertex4sv( const GLshort *v )
  3201. {
  3202.    GET_CONTEXT;
  3203.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  3204.                             (GLfloat) v[2], (GLfloat) v[3] );
  3205. }
  3206.  
  3207.  
  3208. void glVertexPointer( GLint size, GLenum type, GLsizei stride,
  3209.                       const GLvoid *ptr )
  3210. {
  3211.    GET_CONTEXT;
  3212.    (*CC->API.VertexPointer)(CC, size, type, stride, ptr);
  3213. }
  3214.  
  3215.  
  3216. void glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
  3217. {
  3218.    GET_CONTEXT;
  3219.    (*CC->API.Viewport)( CC, x, y, width, height );
  3220. }
  3221.  
  3222.  
  3223.  
  3224. /**
  3225.  ** Extensions
  3226.  **
  3227.  ** Some of these are incorporated into the 1.1 API.  They also remain as
  3228.  ** extensions for backward compatibility.  May be removed in the future.
  3229.  **/
  3230.  
  3231.  
  3232. /* GL_EXT_blend_minmax */
  3233.  
  3234. void glBlendEquationEXT( GLenum mode )
  3235. {
  3236.    GET_CONTEXT;
  3237.    CHECK_CONTEXT;
  3238.    (*CC->API.BlendEquation)(CC, mode);
  3239. }
  3240.  
  3241.  
  3242. /* GL_EXT_blend_color */
  3243.  
  3244. void glBlendColorEXT( GLclampf red, GLclampf green,
  3245.                       GLclampf blue, GLclampf alpha )
  3246. {
  3247.    GET_CONTEXT;
  3248.    CHECK_CONTEXT;
  3249.    (*CC->API.BlendColor)(CC, red, green, blue, alpha);
  3250. }
  3251.  
  3252.  
  3253. /* GL_EXT_vertex_array */
  3254.  
  3255. void glVertexPointerEXT( GLint size, GLenum type, GLsizei stride,
  3256.                          GLsizei count, const GLvoid *ptr )
  3257. {
  3258.    GET_CONTEXT;
  3259.    CHECK_CONTEXT;
  3260.    (*CC->API.VertexPointer)(CC, size, type, stride, ptr);
  3261. }
  3262.  
  3263.  
  3264. void glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count,
  3265.                          const GLvoid *ptr )
  3266. {
  3267.    GET_CONTEXT;
  3268.    CHECK_CONTEXT;
  3269.    (*CC->API.NormalPointer)(CC, type, stride, ptr);
  3270. }
  3271.  
  3272.  
  3273. void glColorPointerEXT( GLint size, GLenum type, GLsizei stride,
  3274.                         GLsizei count, const GLvoid *ptr )
  3275. {
  3276.    GET_CONTEXT;
  3277.    CHECK_CONTEXT;
  3278.    (*CC->API.ColorPointer)(CC, size, type, stride, ptr);
  3279. }
  3280.  
  3281.  
  3282. void glIndexPointerEXT( GLenum type, GLsizei stride,
  3283.                         GLsizei count, const GLvoid *ptr )
  3284. {
  3285.    GET_CONTEXT;
  3286.    CHECK_CONTEXT;
  3287.    (*CC->API.IndexPointer)(CC, type, stride, ptr);
  3288. }
  3289.  
  3290.  
  3291. void glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride,
  3292.                            GLsizei count, const GLvoid *ptr )
  3293. {
  3294.    GET_CONTEXT;
  3295.    CHECK_CONTEXT;
  3296.    (*CC->API.TexCoordPointer)(CC, size, type, stride, ptr);
  3297. }
  3298.  
  3299.  
  3300. void glEdgeFlagPointerEXT( GLsizei stride, GLsizei count,
  3301.                            const GLboolean *ptr )
  3302. {
  3303.    GET_CONTEXT;
  3304.    CHECK_CONTEXT;
  3305.    (*CC->API.EdgeFlagPointer)(CC, stride, ptr);
  3306. }
  3307.  
  3308.  
  3309. void glGetPointervEXT( GLenum pname, GLvoid **params )
  3310. {
  3311.    GET_CONTEXT;
  3312.    CHECK_CONTEXT;
  3313.    (*CC->API.GetPointerv)(CC, pname, params);
  3314. }
  3315.  
  3316.  
  3317. void glArrayElementEXT( GLint i )
  3318. {
  3319.    GET_CONTEXT;
  3320.    CHECK_CONTEXT;
  3321.    (*CC->API.ArrayElement)(CC, i);
  3322. }
  3323.  
  3324.  
  3325. void glDrawArraysEXT( GLenum mode, GLint first, GLsizei count )
  3326. {
  3327.    GET_CONTEXT;
  3328.    CHECK_CONTEXT;
  3329.    (*CC->API.DrawArrays)(CC, mode, first, count);
  3330. }
  3331.  
  3332.  
  3333. /* GL_EXT_texture_object */
  3334.  
  3335. GLboolean glAreTexturesResidentEXT( GLsizei n, const GLuint *textures,
  3336.                                     GLboolean *residences )
  3337. {
  3338.    return glAreTexturesResident( n, textures, residences );
  3339. }
  3340.  
  3341.  
  3342. void glBindTextureEXT( GLenum target, GLuint texture )
  3343. {
  3344.    glBindTexture( target, texture );
  3345. }
  3346.  
  3347.  
  3348. void glDeleteTexturesEXT( GLsizei n, const GLuint *textures)
  3349. {
  3350.    glDeleteTextures( n, textures );
  3351. }
  3352.  
  3353.  
  3354. void glGenTexturesEXT( GLsizei n, GLuint *textures )
  3355. {
  3356.    glGenTextures( n, textures );
  3357. }
  3358.  
  3359.  
  3360. GLboolean glIsTextureEXT( GLuint texture )
  3361. {
  3362.    return glIsTexture( texture );
  3363. }
  3364.  
  3365.  
  3366. void glPrioritizeTexturesEXT( GLsizei n, const GLuint *textures,
  3367.                               const GLclampf *priorities )
  3368. {
  3369.    glPrioritizeTextures( n, textures, priorities );
  3370. }
  3371.  
  3372.  
  3373.  
  3374. /* GL_EXT_texture3D */
  3375.  
  3376. void glCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset,
  3377.                              GLint yoffset, GLint zoffset,
  3378.                              GLint x, GLint y, GLsizei width,
  3379.                              GLsizei height )
  3380. {
  3381.    GET_CONTEXT;
  3382.    CHECK_CONTEXT;
  3383.    (*CC->API.CopyTexSubImage3DEXT)( CC, target, level, xoffset, yoffset,
  3384.                                     zoffset, x, y, width, height );
  3385. }
  3386.  
  3387.  
  3388.  
  3389. void glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat,
  3390.                       GLsizei width, GLsizei height, GLsizei depth,
  3391.                       GLint border, GLenum format, GLenum type,
  3392.                       const GLvoid *pixels )
  3393. {
  3394.    struct gl_image *teximage;
  3395.    GLenum destType;
  3396.    GET_CONTEXT;
  3397.    CHECK_CONTEXT;
  3398.    if (type==GL_UNSIGNED_BYTE) {
  3399.       destType = GL_UNSIGNED_BYTE;
  3400.    }
  3401.    else if (type==GL_BITMAP) {
  3402.       destType = GL_BITMAP;
  3403.    }
  3404.    else {
  3405.       destType = GL_FLOAT;
  3406.    }
  3407.    teximage = gl_unpack_image3D( CC, width, height, depth, format, type,
  3408.                                  destType, pixels, GL_FALSE );
  3409.    (*CC->API.TexImage3DEXT)( CC, target, level, internalformat,
  3410.                              width, height, depth, border, format, type, 
  3411.                              teximage );
  3412. }
  3413.  
  3414.  
  3415. void glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset,
  3416.                          GLint yoffset, GLint zoffset, GLsizei width,
  3417.                          GLsizei height, GLsizei depth, GLenum format,
  3418.                          GLenum type, const GLvoid *pixels )
  3419. {
  3420.    struct gl_image *image;
  3421.    GET_CONTEXT;
  3422.    CHECK_CONTEXT;
  3423.    image = gl_unpack_texsubimage3D( CC, width, height, depth, format, type,
  3424.                                     pixels );
  3425.    (*CC->API.TexSubImage3DEXT)( CC, target, level, xoffset, yoffset, zoffset,
  3426.                                 width, height, depth, format, type, image );
  3427. }
  3428.  
  3429.  
  3430.  
  3431.  
  3432. #ifdef GL_MESA_window_pos
  3433. /*
  3434.  * Mesa implementation of glWindowPos*MESA()
  3435.  */
  3436. void glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  3437. {
  3438.    GET_CONTEXT;
  3439.    CHECK_CONTEXT;
  3440.    (*CC->API.WindowPos4fMESA)( CC, x, y, z, w );
  3441. }
  3442. #else
  3443. /* Implementation in winpos.c is used */
  3444. #endif
  3445.  
  3446.  
  3447. void glWindowPos2iMESA( GLint x, GLint y )
  3448. {
  3449.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  3450. }
  3451.  
  3452. void glWindowPos2sMESA( GLshort x, GLshort y )
  3453. {
  3454.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  3455. }
  3456.  
  3457. void glWindowPos2fMESA( GLfloat x, GLfloat y )
  3458. {
  3459.    glWindowPos4fMESA( x, y, 0.0F, 1.0F );
  3460. }
  3461.  
  3462. void glWindowPos2dMESA( GLdouble x, GLdouble y )
  3463. {
  3464.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  3465. }
  3466.  
  3467. void glWindowPos2ivMESA( const GLint *p )
  3468. {
  3469.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], 0.0F, 1.0F );
  3470. }
  3471.  
  3472. void glWindowPos2svMESA( const GLshort *p )
  3473. {
  3474.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], 0.0F, 1.0F );
  3475. }
  3476.  
  3477. void glWindowPos2fvMESA( const GLfloat *p )
  3478. {
  3479.    glWindowPos4fMESA( p[0], p[1], 0.0F, 1.0F );
  3480. }
  3481.  
  3482. void glWindowPos2dvMESA( const GLdouble *p )
  3483. {
  3484.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], 0.0F, 1.0F );
  3485. }
  3486.  
  3487. void glWindowPos3iMESA( GLint x, GLint y, GLint z )
  3488. {
  3489.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  3490. }
  3491.  
  3492. void glWindowPos3sMESA( GLshort x, GLshort y, GLshort z )
  3493. {
  3494.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  3495. }
  3496.  
  3497. void glWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z )
  3498. {
  3499.    glWindowPos4fMESA( x, y, z, 1.0F );
  3500. }
  3501.  
  3502. void glWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z )
  3503. {
  3504.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  3505. }
  3506.  
  3507. void glWindowPos3ivMESA( const GLint *p )
  3508. {
  3509.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], (GLfloat) p[2], 1.0F );
  3510. }
  3511.  
  3512. void glWindowPos3svMESA( const GLshort *p )
  3513. {
  3514.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], (GLfloat) p[2], 1.0F );
  3515. }
  3516.  
  3517. void glWindowPos3fvMESA( const GLfloat *p )
  3518. {
  3519.    glWindowPos4fMESA( p[0], p[1], p[2], 1.0F );
  3520. }
  3521.  
  3522. void glWindowPos3dvMESA( const GLdouble *p )
  3523. {
  3524.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], (GLfloat) p[2], 1.0F );
  3525. }
  3526.  
  3527. void glWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w )
  3528. {
  3529.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
  3530. }
  3531.  
  3532. void glWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w )
  3533. {
  3534.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
  3535. }
  3536.  
  3537. void glWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
  3538. {
  3539.    glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
  3540. }
  3541.  
  3542.  
  3543. void glWindowPos4ivMESA( const GLint *p )
  3544. {
  3545.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1],
  3546.                       (GLfloat) p[2], (GLfloat) p[3] );
  3547. }
  3548.  
  3549. void glWindowPos4svMESA( const GLshort *p )
  3550. {
  3551.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1],
  3552.                       (GLfloat) p[2], (GLfloat) p[3] );
  3553. }
  3554.  
  3555. void glWindowPos4fvMESA( const GLfloat *p )
  3556. {
  3557.    glWindowPos4fMESA( p[0], p[1], p[2], p[3] );
  3558. }
  3559.  
  3560. void glWindowPos4dvMESA( const GLdouble *p )
  3561. {
  3562.    glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1],
  3563.                       (GLfloat) p[2], (GLfloat) p[3] );
  3564. }
  3565.  
  3566.  
  3567.  
  3568. /* GL_MESA_resize_buffers */
  3569.  
  3570. /*
  3571.  * Called by user application when window has been resized.
  3572.  */
  3573. void glResizeBuffersMESA( void )
  3574. {
  3575.    GET_CONTEXT;
  3576.    CHECK_CONTEXT;
  3577.    (*CC->API.ResizeBuffersMESA)( CC );
  3578. }
  3579.  
  3580.